diff --git a/.editorconfig b/.editorconfig
index 7400f6df98b17..7ff7c2c3d8ba9 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -61,6 +61,9 @@ dotnet_style_coalesce_expression = true:suggestion
 dotnet_style_null_propagation = true:suggestion
 dotnet_style_explicit_tuple_names = true:suggestion
 
+# Whitespace options
+dotnet_style_allow_multiple_blank_lines_experimental = false
+
 # Non-private static fields are PascalCase
 dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.severity = suggestion
 dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.symbols = non_private_static_fields
@@ -182,6 +185,11 @@ csharp_indent_case_contents_when_block = true
 csharp_indent_switch_labels = true
 csharp_indent_labels = flush_left
 
+# Whitespace options
+csharp_style_allow_embedded_statements_on_same_line_experimental = false
+csharp_style_allow_blank_lines_between_consecutive_braces_experimental = false
+csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = false
+
 # Prefer "var" everywhere
 csharp_style_var_for_built_in_types = true:suggestion
 csharp_style_var_when_type_is_apparent = true:suggestion
@@ -233,6 +241,10 @@ csharp_prefer_braces = true:silent
 csharp_preserve_single_line_blocks = true
 csharp_preserve_single_line_statements = true
 
+# Currently only enabled for C# due to crash in VB analyzer.  VB can be enabled once
+# https://github.com/dotnet/roslyn/pull/54259 has been published.
+dotnet_style_allow_statement_immediately_after_block_experimental = false
+
 [src/CodeStyle/**.{cs,vb}]
 # warning RS0005: Do not use generic CodeAction.Create to create CodeAction
 dotnet_diagnostic.RS0005.severity = none
@@ -272,6 +284,21 @@ csharp_style_var_for_built_in_types = true:warning
 csharp_style_var_when_type_is_apparent = true:warning
 csharp_style_var_elsewhere = true:warning
 
+# dotnet_style_allow_multiple_blank_lines_experimental
+dotnet_diagnostic.IDE2000.severity = warning
+
+# csharp_style_allow_embedded_statements_on_same_line_experimental
+dotnet_diagnostic.IDE2001.severity = warning
+
+# csharp_style_allow_blank_lines_between_consecutive_braces_experimental
+dotnet_diagnostic.IDE2002.severity = warning
+
+# dotnet_style_allow_statement_immediately_after_block_experimental
+dotnet_diagnostic.IDE2003.severity = warning
+
+# csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental
+dotnet_diagnostic.IDE2004.severity = warning
+
 [src/{VisualStudio}/**/*.{cs,vb}]
 # CA1822: Make member static
 # Not enforced as a build 'warning' for 'VisualStudio' layer due to large number of false positives from https://github.com/dotnet/roslyn-analyzers/issues/3857 and https://github.com/dotnet/roslyn-analyzers/issues/3858
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 0000000000000..efdda18ee9aca
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,2 @@
+# Dotnet-format -w Roslyn.sln
+abce41d282ac631be5217140f1bd46d0e250ad02
diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index f31edeb4d3bd8..f16df6c5ce694 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -2,14 +2,25 @@ resources:
 - repo: self
   clean: true
 
-# Variables defined in yml cannot be overridden at queue time instead overrideable variables must be defined in the web gui.
-# Commenting out until AzDO supports something like the runtime parameters outlined here: https://github.com/Microsoft/azure-pipelines-yaml/pull/129
-#variables:
-#  SignType: real
-#  SkipTests: false
-#  SkipApplyOptimizationData: false
-#  IbcDrop: 'default'
-#  PRNumber: 'default'
+parameters:
+- name: IbcDrop
+  type: string
+  default: default
+
+- name: SignType
+  default: real
+  type: string
+  values:
+  - real
+  - test
+
+- name: SkipApplyOptimizationData
+  type: boolean
+  default: false
+
+- name: SkipTests
+  type: boolean
+  default: true
 
 # The variables `_DotNetArtifactsCategory` and `_DotNetValidationArtifactsCategory` are required for proper publishing of build artifacts. See https://github.com/dotnet/roslyn/pull/38259
 variables:
@@ -20,46 +31,36 @@ variables:
   - group: DotNet-Roslyn-SDLValidation-Params
 
   # To retrieve OptProf data we need to authenticate to the VS drop storage.
-  # If the pipeline is running in DevDiv, the account has access to the VS drop storage.
-  # Get $AccessToken-dotnet-build-bot-public-repo from DotNet-GitHub-Versions-Repo-Write
-  - ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
-    - group: DotNet-GitHub-Versions-Repo-Write
-    - name: _DevDivDropAccessToken
-      value: $(System.AccessToken)
-  # If the pipeline is running in dnceng:
   # Get access token with $dn-bot-devdiv-drop-rw-code-rw and dn-bot-dnceng-build-rw-code-rw from DotNet-VSTS-Infra-Access
   # Get $dotnetfeed-storage-access-key-1 from DotNet-Blob-Feed
   # Get $microsoft-symbol-server-pat and $symweb-symbol-server-pat from DotNet-Symbol-Server-Pats
   # Get $AccessToken-dotnet-build-bot-public-repo from DotNet-Versions-Publish
-  - ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-    - group: DotNet-Blob-Feed
-    - group: DotNet-Symbol-Server-Pats
-    - group: DotNet-Versions-Publish
-    - group: DotNet-VSTS-Infra-Access
-    - group: DotNet-DevDiv-Insertion-Workflow-Variables
-    - name: _DevDivDropAccessToken
-      value: $(dn-bot-devdiv-drop-rw-code-rw)
+  - group: DotNet-Blob-Feed
+  - group: DotNet-Symbol-Server-Pats
+  - group: DotNet-Versions-Publish
+  - group: DotNet-VSTS-Infra-Access
+  - group: DotNet-DevDiv-Insertion-Workflow-Variables
+  - name: _DevDivDropAccessToken
+    value: $(dn-bot-devdiv-drop-rw-code-rw)
+  - group: ManagedLanguageSecrets
+
+  - name: BuildConfiguration
+    value: release
+  - name: Roslyn.GitHubEmail
+    value: dotnet-build-bot@microsoft.com
+  - name: Roslyn.GitHubToken
+    value: $(AccessToken-dotnet-build-bot-public-repo)
+  - name: Roslyn.GitHubUserName
+    value: dotnet-build-bot
+
+  - name: Insertion.InsertToolset
+    value: true
+  - name: Insertion.CreateDraftPR
+    value: true
+  - name: Insertion.TitlePrefix
+    value: '[Auto Insertion]'
 
 stages:
-- stage: setup
-  displayName: Build Setup
-
-  jobs:
-  - job: SetBuildNumber
-    pool:
-      vmImage: vs2017-win2016
-    steps:
-    # Make sure our two pipelines generate builds with distinct build numbers to avoid confliction.
-    # i.e. DevDiv builds will have even rev# whereas dnceng builds will be odd.
-    - task: PowerShell@2
-      displayName: Update BuildNumber
-      inputs:
-        filePath: 'eng\update-build-number.ps1'
-        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
-          arguments: '-buildNumber $(Build.BuildNumber) -oddOrEven even'
-        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-          arguments: '-buildNumber $(Build.BuildNumber) -oddOrEven odd'
-      condition: eq(variables['System.JobAttempt'], '1')
 
 - stage: build
   displayName: Build and Test
@@ -76,17 +77,9 @@ stages:
   - job: OfficialBuild
     displayName: Official Build
     timeoutInMinutes: 360
-    # Conditionally set build pool so we can share this YAML when building with different pipeline (devdiv vs dnceng)
     pool:
-      ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
-        name: VSEngSS-MicroBuild2017
-        demands:
-        - msbuild
-        - visualstudio
-        - DotNetFramework
-      ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-        name: NetCoreInternal-Pool
-        queue: BuildPool.Server.Amd64.VS2017
+      name: NetCoreInternal-Pool
+      queue: BuildPool.Server.Amd64.VS2017
 
     steps:
     - powershell: Write-Host "##vso[task.setvariable variable=SourceBranchName]$('$(Build.SourceBranch)'.Substring('refs/heads/'.Length))"
@@ -98,23 +91,7 @@ stages:
       inputs:
         type: 'Build'
         tags: 'OfficialBuild'
-      condition: and(succeeded(), endsWith(variables['SourceBranchName'], '-vs-deps'), eq(variables['PRNumber'], 'default'))
-
-    - task: tagBuildOrRelease@0
-      displayName: Tag PR validation build
-      inputs:
-        type: 'Build'
-        tags: |
-          PRValidationBuild
-          PRNumber:$(PRNumber)
-      condition: and(succeeded(), ne(variables['PRNumber'], 'default'))
-
-    - task: PowerShell@2
-      displayName: Setup branch for insertion validation
-      inputs:
-        filePath: 'eng\setup-pr-validation.ps1'
-        arguments: '-sourceBranchName $(SourceBranchName) -prNumber $(PRNumber)'
-      condition: and(succeeded(), ne(variables['PRNumber'], 'default'))
+      condition: and(succeeded(), endsWith(variables['SourceBranchName'], '-vs-deps'))
 
     - task: tagBuildOrRelease@0
       displayName: Tag main validation build
@@ -128,8 +105,7 @@ stages:
       displayName: Merge main-vs-deps into source branch
       inputs:
         filePath: 'scripts\merge-vs-deps.ps1'
-        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-          arguments: '-accessToken $(dn-bot-dnceng-build-rw-code-rw)'
+        arguments: '-accessToken $(dn-bot-dnceng-build-rw-code-rw)'
       condition: and(succeeded(), eq(variables['SourceBranchName'], 'main'))
 
     - powershell: Write-Host "##vso[task.setvariable variable=VisualStudio.DropName]Products/$(System.TeamProject)/$(Build.Repository.Name)/$(SourceBranchName)/$(Build.BuildNumber)"
@@ -142,20 +118,15 @@ stages:
     # Authenticate with service connections to be able to publish packages to external nuget feeds.
     - task: NuGetAuthenticate@0
       inputs:
-        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
-          nuGetServiceConnections: azure-public/vs-impl, azure-public/vssdk
-        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-          nuGetServiceConnections: azure-public/vs-impl, azure-public/vssdk, devdiv/engineering
+        nuGetServiceConnections: azure-public/vs-impl, azure-public/vssdk, devdiv/engineering
 
-    # Needed because the dnceng image we build on fails the next task without it
+    # Needed because the build fails the NuGet Tools restore without it
     - task: UseDotNet@2
       displayName: 'Use .NET Core sdk'
       inputs:
         packageType: sdk
         useGlobalJson: true
         workingDirectory: '$(Build.SourcesDirectory)'
-        installationPath: '$(Build.SourcesDirectory)/.dotnet'
-      condition: eq(variables['System.TeamProject'], 'internal')
 
     # Needed to restore the Microsoft.DevDiv.Optimization.Data.PowerShell package
     - task: NuGetCommand@2
@@ -171,9 +142,7 @@ stages:
       inputs:
         signType: $(SignType)
         zipSources: false
-        # If running in dnceng, we need to use a feed different from default
-        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-          feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
+        feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
       condition: and(succeeded(), in(variables['SignType'], 'test', 'real'))
 
     - task: PowerShell@2
@@ -212,7 +181,7 @@ stages:
       inputs:
         filePath: 'eng\publish-assets.ps1'
         arguments: '-configuration $(BuildConfiguration) -branchName "$(SourceBranchName)"'
-      condition: and(succeeded(), eq(variables['PRNumber'], 'default'))
+      condition: succeeded()
 
     # Publish OptProf configuration files
     # The env variable is required to enable cross account access using PAT (dnceng -> devdiv)
@@ -282,12 +251,8 @@ stages:
         command: push
         packagesToPush: '$(Build.SourcesDirectory)\artifacts\VSSetup\$(BuildConfiguration)\DevDivPackages\**\*.nupkg'
         allowPackageConflicts: true
-        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
-          feedsToUse: config
-          publishVstsFeed: '97a41293-2972-4f48-8c0e-05493ae82010'
-        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-          nuGetFeedType: external
-          publishFeedCredentials: 'DevDiv - VS package feed'
+        nuGetFeedType: external
+        publishFeedCredentials: 'DevDiv - VS package feed'
       condition: succeeded()
 
     # Publish an artifact that the RoslynInsertionTool is able to find by its name.
@@ -325,25 +290,89 @@ stages:
       publishUsingPipelines: true
       dependsOn:
         - OfficialBuild
-      ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
-        queue:
-          name: Hosted VS2017
-      ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-        pool:
-          vmImage: vs2017-win2016
-
-# We need to skip post-build stages for PR validation build, but it can only be identified by
-# the runtime variable 'PRNumber', thus this dummy stage. Also the dummy job is required
-# otherwise AzDO would just repeat jobs from previous stage.
-- stage: SetValidateDependency
-  displayName: Setup the dependency for post-build stages
-  condition: and(succeeded(), eq(variables['PRNumber'], 'default'))
+      pool:
+        vmImage: vs2017-win2016
+
+- stage: insert
+  dependsOn:
+  - build
+  - publish_using_darc
+  displayName: Insert to VS
+
   jobs:
-  - job: Log
-    displayName: Log
+  - job: insert
+    displayName: Insert to VS
+    pool:
+      vmImage: windows-2019
     steps:
-    - powershell: Write-Host "Setup the dependency for post-build stages."
-      displayName: Log
+    - checkout: none
+
+    - task: NuGetCommand@2
+      displayName: 'Install RIT from Azure Artifacts'
+      inputs:
+        command: custom
+        arguments: 'install RoslynTools.VisualStudioInsertionTool -PreRelease -Source https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json'
+
+    - powershell: |
+        $response = Invoke-RestMethod -Headers @{Authorization = "Bearer $(System.AccessToken)"} "https://dev.azure.com/dnceng/internal/_apis/git/repositories/dotnet-roslyn/items?path=eng/config/PublishData.json&api-version=6.0"
+        $branchName = "$(Build.SourceBranch)".Substring("refs/heads/".Length)
+        $branchData = $response.branches.$branchName
+        if (!$branchData)
+        {
+          Write-Host "No PublishData found for branch '$branchName'. Using PublishData for branch 'main'."
+          $branchData = $response.branches.main
+        }
+        if ($null -ne $branchData.insertionCreateDraftPR)
+        {
+          Write-Host "##vso[task.setvariable variable=Insertion.CreateDraftPR]$($branchData.insertionCreateDraftPR)"
+        }
+        if ($null -ne $branchData.insertionTitlePrefix)
+        {
+          Write-Host "##vso[task.setvariable variable=Insertion.TitlePrefix]$($branchData.insertionTitlePrefix)"
+        }
+        if ($null -ne $branchData.insertToolset)
+        {
+          Write-Host "##vso[task.setvariable variable=Insertion.InsertToolset]$($branchData.insertToolset)"
+        }
+
+        Write-Host "##vso[task.setvariable variable=Insertion.AutoComplete]$(-not $branchData.insertionCreateDraftPR)"
+        Write-Host "##vso[task.setvariable variable=ComponentBranchName]$branchName"
+        Write-Host "##vso[task.setvariable variable=VSBranchName]$($branchData.vsBranch)"
+      displayName: Set Insertion Variables
+
+    - powershell: |
+        mv RoslynTools.VisualStudioInsertionTool.* RIT
+        .\RIT\tools\OneOffInsertion.ps1 `
+          -autoComplete "$(Insertion.AutoComplete)" `
+          -buildQueueName "$(Build.DefinitionName)" `
+          -cherryPick "(default)" `
+          -clientId "$(ClientId)" `
+          -clientSecret "$(ClientSecret)" `
+          -componentAzdoUri "$(System.CollectionUri)" `
+          -componentBranchName "$(ComponentBranchName)" `
+          -componentGitHubRepoName "dotnet/roslyn" `
+          -componentName "Roslyn" `
+          -componentProjectName "internal" `
+          -createDraftPR "$(Insertion.CreateDraftPR)" `
+          -defaultValueSentinel "(default)" `
+          -dropPath "(default)" `
+          -insertCore "(default)" `
+          -insertDevDiv "(default)" `
+          -insertionCount "1" `
+          -insertToolset "$(Insertion.InsertToolset)" `
+          -titlePrefix "$(Insertion.TitlePrefix)" `
+          -queueValidation "true" `
+          -requiredValueSentinel "REQUIRED" `
+          -reviewerGUID "6c25b447-1d90-4840-8fde-d8b22cb8733e" `
+          -specificBuild "$(Build.BuildNumber)" `
+          -updateAssemblyVersions "(default)" `
+          -updateCoreXTLibraries "(default)" `
+          -visualStudioBranchName "$(VSBranchName)" `
+          -writePullRequest "prid.txt" `
+      displayName: 'Run OneOffInsertion.ps1'
+
+    - script: 'echo. && echo. && type "prid.txt" && echo. && echo.'
+      displayName: 'Report PR URL'
 
 - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
   - template: eng\common\templates\post-build\post-build.yml
@@ -353,12 +382,6 @@ stages:
       # https://github.com/dotnet/arcade/issues/2871 is resolved.
       enableSymbolValidation: false
       enableSourceLinkValidation: false
-      # It's important that post-build stages are depends on 'SetValidateDependency' stage instead of 'build',
-      # since we don't want to publish validation build.
-      validateDependsOn:
-        - SetValidateDependency
-      dependsOn:
-        - SetValidateDependency
       # Enable SDL validation, passing through values from the 'DotNet-Roslyn-SDLValidation-Params' group.
       SDLValidationParameters:
         enable: true
diff --git a/azure-pipelines-pr-validation.yml b/azure-pipelines-pr-validation.yml
new file mode 100644
index 0000000000000..7f1078fdc5928
--- /dev/null
+++ b/azure-pipelines-pr-validation.yml
@@ -0,0 +1,196 @@
+resources:
+- repo: self
+  clean: true
+
+# Variables defined in yml cannot be overridden at queue time instead overrideable variables must be defined in the web gui.
+# Commenting out until AzDO supports something like the runtime parameters outlined here: https://github.com/Microsoft/azure-pipelines-yaml/pull/129
+#variables:
+#  SignType: test
+#  IbcDrop: 'default'
+
+parameters:
+- name: PRNumber
+  type: number
+- name: CommitSHA
+  type: string
+
+# The variables `_DotNetArtifactsCategory` and `_DotNetValidationArtifactsCategory` are required for proper publishing of build artifacts. See https://github.com/dotnet/roslyn/pull/38259
+variables:
+  - name: _DotNetArtifactsCategory
+    value: .NETCore
+  - name: _DotNetValidationArtifactsCategory
+    value: .NETCoreValidation
+  - group: DotNet-Roslyn-SDLValidation-Params
+
+  # To retrieve OptProf data we need to authenticate to the VS drop storage.
+  # If the pipeline is running in DevDiv, the account has access to the VS drop storage.
+  # Get $AccessToken-dotnet-build-bot-public-repo from DotNet-GitHub-Versions-Repo-Write
+  - group: DotNet-GitHub-Versions-Repo-Write
+  - name: _DevDivDropAccessToken
+    value: $(System.AccessToken)
+
+stages:
+- stage: build
+  displayName: Build and Test
+
+  jobs:
+
+  - job: PRValidationBuild
+    displayName: PR Validation Build
+    timeoutInMinutes: 360
+    # Conditionally set build pool so we can share this YAML when building with different pipeline
+    pool:
+      name: VSEngSS-MicroBuild2017
+      demands:
+      - msbuild
+      - visualstudio
+      - DotNetFramework
+
+    steps:
+    - powershell: Write-Host "##vso[task.setvariable variable=SourceBranchName]$('$(Build.SourceBranch)'.Substring('refs/heads/'.Length))"
+      displayName: Setting SourceBranchName variable
+      condition: succeeded()
+
+    - task: tagBuildOrRelease@0
+      displayName: Tag PR validation build
+      inputs:
+        type: 'Build'
+        tags: |
+          PRValidationBuild
+          PRNumber:${{ parameters.PRNumber }}
+          CommitSHA:${{ parameters.CommitSHA }}
+      condition: succeeded()
+
+    - task: PowerShell@2
+      displayName: Setup branch for insertion validation
+      inputs:
+        filePath: 'eng\setup-pr-validation.ps1'
+        arguments: '-sourceBranchName $(SourceBranchName) -prNumber ${{ parameters.PRNumber }} -commitSHA ${{ parameters.CommitSHA }}'
+      condition: succeeded()
+
+    - powershell: Write-Host "##vso[task.setvariable variable=VisualStudio.DropName]Products/$(System.TeamProject)/$(Build.Repository.Name)/$(SourceBranchName)/$(Build.BuildNumber)"
+      displayName: Setting VisualStudio.DropName variable
+
+    - task: NuGetToolInstaller@0
+      inputs:
+        versionSpec: '4.9.2'
+
+    # Authenticate with service connections to be able to publish packages to external nuget feeds.
+    - task: NuGetAuthenticate@0
+      inputs:
+        nuGetServiceConnections: azure-public/vs-impl, azure-public/vssdk
+
+    # Needed to restore the Microsoft.DevDiv.Optimization.Data.PowerShell package
+    - task: NuGetCommand@2
+      displayName: Restore internal tools
+      inputs:
+        command: restore
+        feedsToUse: config
+        restoreSolution: 'eng\common\internal\Tools.csproj'
+        nugetConfigPath: 'NuGet.config'
+        restoreDirectory: '$(Build.SourcesDirectory)\.packages'
+
+    - task: MicroBuildSigningPlugin@2
+      inputs:
+        signType: $(SignType)
+        zipSources: false
+      condition: and(succeeded(), in(variables['SignType'], 'test', 'real'))
+
+    - task: PowerShell@2
+      displayName: Build
+      inputs:
+        filePath: eng/build.ps1
+        arguments: -ci
+                   -restore
+                   -build
+                   -pack
+                   -sign
+                   -publish
+                   -binaryLog
+                   -configuration $(BuildConfiguration)
+                   -officialBuildId $(Build.BuildNumber)
+                   -officialSkipTests $(SkipTests)
+                   -officialSkipApplyOptimizationData $(SkipApplyOptimizationData)
+                   -officialSourceBranchName $(SourceBranchName)
+                   -officialIbcDrop $(IbcDrop)
+                   -officialVisualStudioDropAccessToken $(_DevDivDropAccessToken)
+                   /p:RepositoryName=$(Build.Repository.Name)
+                   /p:VisualStudioDropName=$(VisualStudio.DropName)
+                   /p:DotNetSignType=$(SignType)
+                   /p:DotNetPublishToBlobFeed=false
+                   /p:PublishToSymbolServer=false
+                   /p:DotNetSymbolServerTokenMsdl=$(microsoft-symbol-server-pat)
+                   /p:DotNetSymbolServerTokenSymWeb=$(symweb-symbol-server-pat)
+                   /p:DotNetArtifactsCategory=$(_DotNetArtifactsCategory)
+                   /p:DotnetPublishUsingPipelines=false
+                   /p:PreReleaseVersionLabel=pr-validation
+      condition: succeeded()
+
+    # Publish OptProf generated JSON files as a build artifact. This allows for easy inspection from
+    # a build execution.
+    - task: PublishBuildArtifacts@1
+      displayName: Publish OptProf Data Files
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)\artifacts\OptProf\$(BuildConfiguration)\Data'
+        ArtifactName: 'OptProf Data Files'
+      condition: succeeded()
+
+    - task: PublishBuildArtifacts@1
+      displayName: Publish Logs
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)\artifacts\log\$(BuildConfiguration)'
+        ArtifactName: 'Build Diagnostic Files'
+        publishLocation: Container
+      continueOnError: true
+      condition: succeededOrFailed()
+
+    - task: PublishBuildArtifacts@1
+      displayName: Publish Ngen Logs
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)\artifacts\log\$(BuildConfiguration)\ngen'
+        ArtifactName: 'NGen Logs'
+        publishLocation: Container
+      continueOnError: true
+      condition: succeeded()
+
+    - task: PublishTestResults@2
+      displayName: Publish xUnit Test Results
+      inputs:
+        testRunner: XUnit
+        testResultsFiles: '$(Build.SourcesDirectory)\artifacts\TestResults\$(BuildConfiguration)\*.xml'
+        mergeTestResults: true
+        testRunTitle: 'Unit Tests'
+      condition: and(succeededOrFailed(), ne(variables['SkipTests'], 'true'))
+
+    # Publishes setup VSIXes to a drop.
+    # Note: The insertion tool looks for the display name of this task in the logs.
+    - task: ms-vseng.MicroBuildTasks.4305a8de-ba66-4d8b-b2d1-0dc4ecbbf5e8.MicroBuildUploadVstsDropFolder@1
+      displayName: Upload VSTS Drop
+      inputs:
+        DropName: $(VisualStudio.DropName)
+        DropFolder: 'artifacts\VSSetup\$(BuildConfiguration)\Insertion'
+        AccessToken: $(_DevDivDropAccessToken)
+      condition: succeeded()
+
+    # Publish insertion packages to CoreXT store.
+    - task: NuGetCommand@2
+      displayName: Publish CoreXT Packages
+      inputs:
+        command: push
+        packagesToPush: '$(Build.SourcesDirectory)\artifacts\VSSetup\$(BuildConfiguration)\DevDivPackages\**\*.nupkg'
+        allowPackageConflicts: true
+        feedsToUse: config
+        publishVstsFeed: '97a41293-2972-4f48-8c0e-05493ae82010'
+      condition: succeeded()
+
+    # Publish an artifact that the RoslynInsertionTool is able to find by its name.
+    - task: PublishBuildArtifacts@1
+      displayName: Publish Artifact VSSetup
+      inputs:
+        PathtoPublish: 'artifacts\VSSetup\$(BuildConfiguration)'
+        ArtifactName: 'VSSetup'
+      condition: succeeded()
+
+    - task: ms-vseng.MicroBuildTasks.521a94ea-9e68-468a-8167-6dcf361ea776.MicroBuildCleanup@1
+      displayName: Perform Cleanup Tasks
+      condition: succeededOrFailed()
diff --git a/azure-pipelines-richnav.yml b/azure-pipelines-richnav.yml
index 6652eb3757fae..d327060f6c65e 100644
--- a/azure-pipelines-richnav.yml
+++ b/azure-pipelines-richnav.yml
@@ -1,6 +1,20 @@
+# Branches that trigger a build on commit
 trigger:
 - main
+- main-vs-deps
+- release/*
+- features/*
+- demos/*
+
+# Branches that trigger builds on PR
 pr: none
+# Temporarily disabling richnav job on PRs
+# pr:
+# - main
+# - main-vs-deps
+# - release/*
+# - features/*
+# - demos/*
 
 jobs:
 - job: RichCodeNav_Indexing
diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md
index 5a28acb0fe789..768a966e61f4e 100644
--- a/docs/Language Feature Status.md	
+++ b/docs/Language Feature Status.md	
@@ -10,27 +10,34 @@ efforts behind them.
 
 | Feature | Branch | State | Developer | Reviewer | LDM Champ |
 | ------- | ------ | ----- | --------- | -------- | --------- |
-| [Record structs](https://github.com/dotnet/csharplang/issues/4334) | [record-structs](https://github.com/dotnet/roslyn/tree/features/record-structs) | [In Progress](https://github.com/dotnet/roslyn/issues/51199) | [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs), [RikkiGibson](https://github.com/RikkiGibson) | [jcouv](https://github.com/jcouv) |
-| [Global Using Directive](https://github.com/dotnet/csharplang/issues/3428) | [GlobalUsingDirective](https://github.com/dotnet/roslyn/tree/features/GlobalUsingDirective) | [In Progress](https://github.com/dotnet/roslyn/issues/51307) | [AlekseyTs](https://github.com/AlekseyTs) | [333fred](https://github.com/333fred), [cston](https://github.com/cston) | [AlekseyTs](https://github.com/AlekseyTs) |
 | [Static Abstract Members In Interfaces](https://github.com/dotnet/csharplang/issues/4436) | [StaticAbstractMembersInInterfaces](https://github.com/dotnet/roslyn/tree/features/StaticAbstractMembersInInterfaces) | [In Progress](https://github.com/dotnet/roslyn/issues/52221) | [AlekseyTs](https://github.com/AlekseyTs) | [333fred](https://github.com/333fred), [RikkiGibson](https://github.com/RikkiGibson) | [MadsTorgersen](https://github.com/MadsTorgersen) |
 | [File-scoped namespace](https://github.com/dotnet/csharplang/issues/137) | [FileScopedNamespaces](https://github.com/dotnet/roslyn/tree/features/FileScopedNamespaces) | [In Progress](https://github.com/dotnet/roslyn/issues/49000) | [RikkiGibson](https://github.com/RikkiGibson) | [jcouv](https://github.com/jcouv), [chsienki](https://github.com/chsienki) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) |
 | [Interpolated string improvements](https://github.com/dotnet/csharplang/issues/4487) | [interpolated-string](https://github.com/dotnet/roslyn/tree/features/interpolated-string) | [In Progress](https://github.com/dotnet/roslyn/issues/51499) | [333fred](https://github.com/333fred) | [AlekseyTs](https://github.com/AlekseyTs), [chsienki](https://github.com/chsienki) | [jaredpar](https://github.com/jaredpar) |
 | [Parameterless struct constructors](https://github.com/dotnet/csharplang/issues/99) | [struct-ctors](https://github.com/dotnet/roslyn/tree/features/struct-ctors) | [In Progress](https://github.com/dotnet/roslyn/issues/51698) | [cston](https://github.com/cston) | [jcouv](https://github.com/jcouv), [333fred](https://github.com/333fred) | [jcouv](https://github.com/jouv) |
 | [Lambda improvements](https://github.com/dotnet/csharplang/blob/main/proposals/lambda-improvements.md) | [lambdas](https://github.com/dotnet/roslyn/tree/features/lambdas) | [In Progress](https://github.com/dotnet/roslyn/issues/52192) | [cston](https://github.com/cston) | [333fred](https://github.com/333fred), [jcouv](https://github.com/jcouv) | [jaredpar](https://github.com/jaredpar) |
 | [nameof(parameter)](https://github.com/dotnet/csharplang/issues/373) | main | [In Progress](https://github.com/dotnet/roslyn/issues/40524) | [jcouv](https://github.com/jcouv) | TBD | [jcouv](https://github.com/jcouv) |
-| [Improved Definite Assignment](https://github.com/dotnet/csharplang/issues/4465) | [improved-definite-assignment](https://github.com/dotnet/roslyn/tree/features/improved-definite-assignment) | [Merged into 17.0](https://github.com/dotnet/roslyn/issues/51463) | [RikkiGibson](https://github.com/RikkiGibson) | [jcouv](https://github.com/jcouv) | [jaredpar](https://github.com/jaredpar) |
 | [Relax ordering of `ref` and `partial` modifiers](https://github.com/dotnet/csharplang/issues/946) | [ref-partial](https://github.com/dotnet/roslyn/tree/features/ref-partial) | In Progress | [alrz](https://github.com/alrz) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
 | [Parameter null-checking](https://github.com/dotnet/csharplang/issues/2145) | [param-nullchecking](https://github.com/dotnet/roslyn/tree/features/param-nullchecking) | [In Progress](https://github.com/dotnet/roslyn/issues/36024) | [fayrose](https://github.com/fayrose) | [agocke](https://github.com/agocke) | [jaredpar](https://github.com/jaredpar) |
 | [Caller expression attribute](https://github.com/dotnet/csharplang/issues/287) | [caller-argument-expression](https://github.com/dotnet/roslyn/tree/features/caller-argument-expression) | [In Progress](https://github.com/dotnet/roslyn/issues/52745) | [Youssef1313](https://github.com/Youssef1313) | [333fred](https://github.com/333fred),[AlekseyTs](https://github.com/AlekseyTs) | [jcouv](https://github.com/jcouv) |
 | [Generic attributes](https://github.com/dotnet/csharplang/issues/124) | [generic-attributes](https://github.com/dotnet/roslyn/tree/features/generic-attributes) | [In Progress](https://github.com/dotnet/roslyn/issues/36285) | [AviAvni](https://github.com/AviAvni) | [agocke](https://github.com/agocke) | [mattwar](https://github.com/mattwar) |
 | [Default in deconstruction](https://github.com/dotnet/roslyn/pull/25562) | [decon-default](https://github.com/dotnet/roslyn/tree/features/decon-default) | [Implemented](https://github.com/dotnet/roslyn/issues/25559) | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
-| [Constant Interpolated Strings](https://github.com/dotnet/csharplang/issues/2951) | main | [Merged into 16.9p3](https://github.com/dotnet/roslyn/pull/49676)  | [kevinsun-dev](https://github.com/kevinsun-dev) | [333fred](https://github.com/333fred) | [jaredar](https://github.com/jaredpar), [agocke](https://github.com/agocke) |
-| [Mix declarations and variables in deconstruction](https://github.com/dotnet/csharplang/issues/125) | main | [Merged into 16.10](https://github.com/dotnet/roslyn/issues/47746) | [YairHalberstadt ](https://github.com/YairHalberstadt) | [jcouv](https://github.com/jcouv) | [MadsTorgersen](https://github.com/MadsTorgersen) |
 | [List patterns](https://github.com/dotnet/csharplang/issues/3435) | [list-patterns](https://github.com/dotnet/roslyn/tree/features/list-patterns) | [In Progress](https://github.com/dotnet/roslyn/issues/51289) | [alrz](https://github.com/alrz) | [jcouv](https://github.com/jcouv), [333fred](https://github.com/333fred) | [333fred](https://github.com/333fred) |
+
+
+# C# 10.0
+
+| Feature | Branch | State | Developer | Reviewer | LDM Champ |
+| ------- | ------ | ----- | --------- | -------- | --------- |
+| [Record structs](https://github.com/dotnet/csharplang/issues/4334) | [record-structs](https://github.com/dotnet/roslyn/tree/features/record-structs) | [Merged into 16.11](https://github.com/dotnet/roslyn/issues/51199) | [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs), [RikkiGibson](https://github.com/RikkiGibson) | [jcouv](https://github.com/jcouv) |
+| [Global Using Directive](https://github.com/dotnet/csharplang/issues/3428) | [GlobalUsingDirective](https://github.com/dotnet/roslyn/tree/features/GlobalUsingDirective) | [Merged into 16.11](https://github.com/dotnet/roslyn/issues/51307) | [AlekseyTs](https://github.com/AlekseyTs) | [333fred](https://github.com/333fred), [cston](https://github.com/cston) | [AlekseyTs](https://github.com/AlekseyTs) |
+| [Improved Definite Assignment](https://github.com/dotnet/csharplang/issues/4465) | [improved-definite-assignment](https://github.com/dotnet/roslyn/tree/features/improved-definite-assignment) | [Merged into 17.0](https://github.com/dotnet/roslyn/issues/51463) | [RikkiGibson](https://github.com/RikkiGibson) | [jcouv](https://github.com/jcouv) | [jaredpar](https://github.com/jaredpar) |
+| [Constant Interpolated Strings](https://github.com/dotnet/csharplang/issues/2951) | main | [Merged into 16.9p3](https://github.com/dotnet/roslyn/pull/49676)  | [kevinsun-dev](https://github.com/kevinsun-dev) | [333fred](https://github.com/333fred) | [jaredar](https://github.com/jaredpar), [agocke](https://github.com/agocke) |
 | [Extended property patterns](https://github.com/dotnet/csharplang/issues/4394) | [extended-property-patterns](https://github.com/dotnet/roslyn/tree/features/extended-property-patterns) | [Merged into 17.0](https://github.com/dotnet/roslyn/issues/52468) | [alrz](https://github.com/alrz) | [jcouv](https://github.com/jcouv), [333fred](https://github.com/333fred) | [333fred](https://github.com/333fred) |
 | [Sealed record ToString](https://github.com/dotnet/csharplang/issues/4174) | main | [Merged](https://github.com/dotnet/roslyn/issues/52031) | [thomaslevesque](https://github.com/thomaslevesque/) | [jcouv](https://github.com/jcouv) | [333fred](https://github.com/333fred) |
-| [Source Generator V2 APIs](https://github.com/dotnet/roslyn/issues/51257) | [features/source-generators](https://github.com/dotnet/roslyn/tree/features/source-generators) | [In Progress](https://github.com/dotnet/roslyn/issues/51257) | [chsienki](https://github.com/chsienki/) | [rikkigibson](https://github.com/rikkigibson), [jaredpar](https://github.com/jaredpar), [cston](https://github.com/cston) | N/A |
-| [Async method builder override](https://github.com/dotnet/csharplang/issues/1407) | main | [In Progress](https://github.com/dotnet/roslyn/issues/51999) | [jcouv](https://github.com/jcouv) | TBD | [stephentoub](https://github.com/stephentoub) |
+| [Source Generator V2 APIs](https://github.com/dotnet/roslyn/issues/51257) | [features/source-generators](https://github.com/dotnet/roslyn/tree/features/source-generators) | [Merged into 17.0p2](https://github.com/dotnet/roslyn/issues/51257) | [chsienki](https://github.com/chsienki/) | [rikkigibson](https://github.com/rikkigibson), [jaredpar](https://github.com/jaredpar), [cston](https://github.com/cston) | N/A |
+| [Mix declarations and variables in deconstruction](https://github.com/dotnet/csharplang/issues/125) | main | [Merged into 16.10](https://github.com/dotnet/roslyn/issues/47746) | [YairHalberstadt ](https://github.com/YairHalberstadt) | [jcouv](https://github.com/jcouv) | [MadsTorgersen](https://github.com/MadsTorgersen) |
+| [Async method builder override](https://github.com/dotnet/csharplang/issues/1407) | main | [Merged into 17.0p2](https://github.com/dotnet/roslyn/issues/51999) | [jcouv](https://github.com/jcouv) | [cston](https://github.com/cston), [RikkiGibson](https://github.com/RikkiGibson) | [stephentoub](https://github.com/stephentoub) |
+| [Enhanced `#line` directive](https://github.com/dotnet/csharplang/issues/4747) | main | [Merged into 17.0p2](https://github.com/dotnet/roslyn/issues/54509) | [cston](https://github.com/cston) | [jcouv](https://github.com/jcouv), [RikkiGibson](https://github.com/RikkiGibson) | [MadsTorgersen](https://github.com/MadsTorgersen) |
 
 # VB 16.9
 
diff --git a/docs/features/StaticAbstractMembersInInterfaces.md b/docs/features/StaticAbstractMembersInInterfaces.md
new file mode 100644
index 0000000000000..ed49e08974677
--- /dev/null
+++ b/docs/features/StaticAbstractMembersInInterfaces.md
@@ -0,0 +1,14 @@
+Static Abstract Members In Interfaces
+=====================================
+
+An interface is allowed to specify abstract static members that implementing classes and structs are then
+required to provide an explicit or implicit implementation of. The members can be accessed off of type
+parameters that are constrained by the interface.
+
+Proposal: 
+- https://github.com/dotnet/csharplang/issues/4436
+- https://github.com/dotnet/csharplang/blob/main/proposals/static-abstracts-in-interfaces.md
+
+Feature branch: https://github.com/dotnet/roslyn/tree/features/StaticAbstractMembersInInterfaces
+
+Test plan: https://github.com/dotnet/roslyn/issues/52221
\ No newline at end of file
diff --git a/docs/features/refout.md b/docs/features/refout.md
index 0571529797481..4487d9f006353 100644
--- a/docs/features/refout.md
+++ b/docs/features/refout.md
@@ -61,13 +61,13 @@ An additional task, called `CopyRefAssembly`, is provided along with the existin
 As a side-note, `CopyRefAssembly` uses the same assembly resolution/redirection trick as `Csc` and `Vbc`, to avoid type loading problems with `System.IO.FileSystem`.
 
 ### CodeAnalysis APIs
-Prior to C# 7.1, it was already possible to produce metadata-only assemblies by using `EmitOptions.EmitMetadataOnly`, which is used in IDE scenarios with cross-language dependencies.
+Prior to C# 7.1, it was already possible to produce metadata-only assemblies by using `EmitOptions.EmitMetadataOnly`, which is used in IDE scenarios with cross-language dependencies.  
 
-With C# 7.1, the compiler now honours the `EmitOptions.IncludePrivateMembers` flag as well. When combined with `EmitMetadataOnly` or a `metadataPeStream` in `Emit`, a ref assembly is produced.
+With C# 7.1, the compiler now honours the `EmitOptions.IncludePrivateMembers` flag as well. When combined with `EmitMetadataOnly` or a `metadataPeStream` in `Emit`, a ref assembly is produced.  
 
-The diagnostic check for emitting methods lacking a body (`void M();`) is filtered from declaration diagnostics, so such code will successfully emit with `EmitMetadataOnly`.
+Method bodies aren't compiled when using `EmitMetadataOnly`. Even the diagnostic check for emitting methods lacking a body (`void M();`) is filtered from declaration diagnostics, so such code will successfully emit with `EmitMetadataOnly`.  
 
-Later on, the `EmitOptions.TolerateErrors` flag will allow emitting error types as well.
+Later on, the `EmitOptions.TolerateErrors` flag will allow emitting error types as well.  
 `Emit` was modified to produce a new PE section called ".mvid" containing a copy of the MVID, when emitting ref assemblies. This makes it easy for `CopyRefAssembly` to extract and compare MVIDs from ref assemblies.
 
 Going back to the 4 driving scenarios:
diff --git a/dotnet-tools.json b/dotnet-tools.json
index 10d642464725d..6ab0998319770 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -2,7 +2,7 @@
   "isRoot": true,
   "tools": {
     "dotnet-format": {
-      "version": "5.0.141503",
+      "version": "6.0.231801",
       "commands": [
         "dotnet-format"
       ]
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 1550d473a9f8a..629edf6934c73 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -6,9 +6,9 @@
       <Sha>7e80445ee82adbf9a8e6ae601ac5e239d982afaa</Sha>
       <SourceBuild RepoName="xliff-tasks" ManagedOnly="true" />
     </Dependency>
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build" Version="0.1.0-alpha.1.21126.2">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build" Version="0.1.0-alpha.1.21330.2">
       <Uri>https://github.com/dotnet/source-build</Uri>
-      <Sha>c06ae1212bd69e9fe52bed0b0a7d79cc8ea39054</Sha>
+      <Sha>bf8af9a5202d5016b4bcf3424fac6bac55ef7c8e</Sha>
       <SourceBuild RepoName="source-build" ManagedOnly="true" />
     </Dependency>
   </ProductDependencies>
@@ -18,9 +18,9 @@
       <Sha>78da7776965b428ff31da8f1ff2cb073506212b7</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
-    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.0.0-2.21253.8">
+    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.0.0-2.21327.4">
       <Uri>https://github.com/dotnet/roslyn</Uri>
-      <Sha>5b972bceb846f5d15f991a479e285067a75103e4</Sha>
+      <Sha>03a07d1dd606ce11d62c9a595041c4c2d44c39e3</Sha>
     </Dependency>
     <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="6.0.0-beta.21303.2">
       <Uri>https://github.com/dotnet/arcade</Uri>
diff --git a/eng/Versions.props b/eng/Versions.props
index 5b00a7d5603e9..c2b3f72ab58ce 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -8,7 +8,7 @@
     <MajorVersion>4</MajorVersion>
     <MinorVersion>0</MinorVersion>
     <PatchVersion>0</PatchVersion>
-    <PreReleaseVersionLabel>2</PreReleaseVersionLabel>
+    <PreReleaseVersionLabel>3</PreReleaseVersionLabel>
     <VersionPrefix>$(MajorVersion).$(MinorVersion).$(PatchVersion)</VersionPrefix>
     <!--
       By default the assembly version in official builds is "$(MajorVersion).$(MinorVersion).0.0".
@@ -23,18 +23,18 @@
     </MajorVersion>
     <MinorVersion>
     </MinorVersion>
-    <MicrosoftNetCompilersToolsetVersion>4.0.0-2.21253.8</MicrosoftNetCompilersToolsetVersion>
+    <MicrosoftNetCompilersToolsetVersion>4.0.0-2.21327.4</MicrosoftNetCompilersToolsetVersion>
   </PropertyGroup>
   <PropertyGroup>
     <!-- Versions used by several individual references below -->
     <RoslynDiagnosticsNugetPackageVersion>3.3.3-beta1.21105.3</RoslynDiagnosticsNugetPackageVersion>
     <MicrosoftCodeAnalysisNetAnalyzersVersion>6.0.0-preview1.21054.10</MicrosoftCodeAnalysisNetAnalyzersVersion>
-    <MicrosoftCodeAnalysisTestingVersion>1.0.1-beta1.20623.3</MicrosoftCodeAnalysisTestingVersion>
-    <CodeStyleAnalyzerVersion>3.9.0</CodeStyleAnalyzerVersion>
+    <MicrosoftCodeAnalysisTestingVersion>1.1.0-beta1.21322.2</MicrosoftCodeAnalysisTestingVersion>
+    <CodeStyleAnalyzerVersion>3.10.0</CodeStyleAnalyzerVersion>
     <VisualStudioEditorPackagesVersion>16.10.230</VisualStudioEditorPackagesVersion>
     <ILAsmPackageVersion>5.0.0-alpha1.19409.1</ILAsmPackageVersion>
     <ILDAsmPackageVersion>5.0.0-preview.1.20112.8</ILDAsmPackageVersion>
-    <MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>16.10.1202</MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>
+    <MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>16.11.2</MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>
     <MicrosoftVisualStudioShellPackagesVersion>16.10.31320.204</MicrosoftVisualStudioShellPackagesVersion>
     <MicrosoftBuildPackagesVersion>16.5.0</MicrosoftBuildPackagesVersion>
     <!-- The version of Roslyn we build Source Generators against that are built in this
diff --git a/eng/config/PublishData.json b/eng/config/PublishData.json
index 3e752dd255d60..72df9d4da8fbc 100644
--- a/eng/config/PublishData.json
+++ b/eng/config/PublishData.json
@@ -173,7 +173,8 @@
       "packageFeeds": "default",
       "channels": [],
       "vsBranch": "rel/d16.10",
-      "vsMajorVersion": 16
+      "vsMajorVersion": 16,
+      "insertionTitlePrefix": "[d16.10]"
     },
     "release/dev16.11-vs-deps": {
       "nugetKind": [
@@ -184,9 +185,10 @@
       "packageFeeds": "default",
       "channels": [],
       "vsBranch": "rel/d16.11",
-      "vsMajorVersion": 16
+      "vsMajorVersion": 16,
+      "insertionTitlePrefix": "[d16.11]"
     },
-    "release/dev17.0-preview1-vs-deps": {
+    "release/dev17.0-vs-deps": {
       "nugetKind": [
         "Shipping",
         "NonShipping"
@@ -194,8 +196,9 @@
       "version": "4.0.*",
       "packageFeeds": "default",
       "channels": [],
-      "vsBranch": "rel/d17.0",
-      "vsMajorVersion": 17
+      "vsBranch": "main",
+      "vsMajorVersion": 17,
+      "insertionTitlePrefix": "[d17p2]"
     },
     "main-vs-deps": {
       "nugetKind": [
@@ -206,7 +209,9 @@
       "packageFeeds": "default",
       "channels": [],
       "vsBranch": "main",
-      "vsMajorVersion": 17
+      "vsMajorVersion": 17,
+      "insertionCreateDraftPR": true,
+      "insertionTitlePrefix": "[d17p3]"
     },
     "main": {
       "nugetKind": [
@@ -217,7 +222,8 @@
       "packageFeeds": "arcade",
       "channels": [],
       "vsBranch": "main",
-      "vsMajorVersion": 17
+      "vsMajorVersion": 17,
+      "insertionTitlePrefix": "[Validation]"
     },
     "features/NullableReferenceTypes": {
       "nugetKind": "PerBuildPreRelease",
diff --git a/eng/setup-pr-validation.ps1 b/eng/setup-pr-validation.ps1
index f65ac65de526e..44f3e7d07f6c8 100644
--- a/eng/setup-pr-validation.ps1
+++ b/eng/setup-pr-validation.ps1
@@ -1,24 +1,40 @@
 [CmdletBinding(PositionalBinding=$false)]
 param (
   [string]$sourceBranchName,
-  [string]$prNumber)
+  [string]$prNumber,
+  [string]$commitSHA)
 
-try {  
-    # name and email are only used for merge commit, it doesn't really matter what we put in there.    
+try {
+    # name and email are only used for merge commit, it doesn't really matter what we put in there.
     git config user.name "RoslynValidation"
-    git config user.email "validation@roslyn.net"   
-    
+    git config user.email "validation@roslyn.net"
+
     if ($sourceBranchName -notlike '*-vs-deps') {
       Write-Host  "##vso[task.LogIssue type=warning;]The base branch for insertion validation is $sourceBranchName, which is not a vs-deps branch."
     }
+
+    Write-Host "Validating the PR head matches the specified commit SHA ($commitSHA)..."
+    if ($commitSHA.Length -lt 7) {
+      Write-Host "##vso[task.LogIssue type=error;]The PR Commit SHA must be at least 7 characters long."
+      exit 1
+    }
+
+    Write-Host "Getting the hash of refs/pull/$prNumber/head..."
+    $remoteRef = git ls-remote origin refs/pull/$prNumber/head
+    Write-Host ($remoteRef | Out-String)
+
+    $prHeadSHA = $remoteRef.Split()[0]
+    if (!$prHeadSHA.StartsWith($commitSHA)) {
+      Write-Host "##vso[task.LogIssue type=error;]The PR's Head SHA ($prHeadSHA) does not begin with the specified commit SHA ($commitSHA). Unreviewed changes may have been pushed to the PR."
+      exit 1
+    }
+
     Write-Host "Setting up the build for PR validation by merging refs/pull/$prNumber/merge into $sourceBranchName..."
     git pull origin refs/pull/$prNumber/merge
     if (!$?) {
       Write-Host "##vso[task.LogIssue type=error;]Merging branch refs/pull/$prNumber/merge failed."
       exit 1
     }
-    Write-Host "Getting the hash of refs/pull/$prNumber/head..."
-    Write-Host ((git ls-remote origin refs/pull/$prNumber/head) | Out-String)
 }
 catch {
   Write-Host $_
diff --git a/eng/targets/Services.props b/eng/targets/Services.props
index 4d0838ab724d6..2e698c672e298 100644
--- a/eng/targets/Services.props
+++ b/eng/targets/Services.props
@@ -35,6 +35,7 @@
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.SymbolSearchUpdate" ClassName="Microsoft.CodeAnalysis.Remote.RemoteSymbolSearchUpdateService+Factory" IsBrokered="true" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.TodoCommentsDiscovery" ClassName="Microsoft.CodeAnalysis.Remote.RemoteTodoCommentsDiscoveryService+Factory" IsBrokered="true" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.EditAndContinue" ClassName="Microsoft.CodeAnalysis.EditAndContinue.RemoteEditAndContinueService+Factory" IsBrokered="true" />
+    <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.ValueTracking" ClassName="Microsoft.CodeAnalysis.Remote.RemoteValueTrackingService+Factory" IsBrokered="true" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.InheritanceMargin" ClassName="Microsoft.CodeAnalysis.Remote.RemoteInheritanceMarginService+Factory" IsBrokered="true" />
     <ServiceHubService Include="roslynRemoteLanguageServer" ClassName="Microsoft.CodeAnalysis.Remote.RemoteLanguageServer" />
   </ItemGroup>
diff --git a/eng/targets/VisualStudio.targets b/eng/targets/VisualStudio.targets
index c538278ae5690..0b8de58c9b7f8 100644
--- a/eng/targets/VisualStudio.targets
+++ b/eng/targets/VisualStudio.targets
@@ -139,5 +139,14 @@
     <PackageReference Include="Microsoft.DiaSymReader.Native" Version="$(MicrosoftDiaSymReaderNativeVersion)" ExcludeAssets="all"/>
   </ItemGroup>
 
+  <Target Name="_CheckDeploymentTargetVisualStudioVersion"
+		      Condition="'$(DeployExtension)' == 'true' and '$(CreateVsixContainer)' == 'true'"
+          BeforeTargets="DeployVsixExtensionFiles"
+	       	DependsOnTargets="GetVsixDeploymentPath">
+
+    <Error Text="Deployment to Dev17 is not supported in this branch. Use the corresponding *-vs-deps branch." 
+           Condition="$([MSBuild]::ValueOrDefault('$(ExtensionsPath)', '').Contains('17.0'))"/>
+  </Target>
+
   <Import Project="GeneratePkgDef.targets" Condition="'$(MSBuildRuntimeType)' != 'Core' and '$(GeneratePkgDefFile)' == 'true' and '$(DesignTimeBuild)' != 'true' and '$(BuildingForLiveUnitTesting)' != 'true'" />
 </Project>
\ No newline at end of file
diff --git a/eng/update-build-number.ps1 b/eng/update-build-number.ps1
deleted file mode 100644
index ccab69eec62dc..0000000000000
--- a/eng/update-build-number.ps1
+++ /dev/null
@@ -1,20 +0,0 @@
-[CmdletBinding(PositionalBinding=$false)]
-param (
-  [string]$buildNumber,
-  [string]$oddOrEven)
-
-# Build number is in the format of YYYYMMDD.R
-$buildNumberYYYYMMDD = $buildNumber.Substring(0, 8)
-$buildNumberRev = [int]($buildNumber.Substring(9))
-$updatedRev = $buildNumberRev
-
-if ($oddOrEven -eq 'odd') {
-  $updatedRev = $buildNumberRev * 2 -1
-}
-elseif ($oddOrEven -eq 'even') {
-  $updatedRev = $buildNumberRev * 2
-}
-
-$updatedBuildNumber = $buildNumberYYYYMMDD + '.' + $updatedRev
-Write-Host "Setting BuildNumber to $updatedBuildNumber"
-Write-Host "##vso[build.updatebuildnumber]$updatedBuildNumber"
\ No newline at end of file
diff --git a/src/Analyzers/CSharp/Analyzers/AddAccessibilityModifiers/CSharpAddAccessibilityModifiersDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/AddAccessibilityModifiers/CSharpAddAccessibilityModifiersDiagnosticAnalyzer.cs
index a6f3580f908c6..b47871a2d1323 100644
--- a/src/Analyzers/CSharp/Analyzers/AddAccessibilityModifiers/CSharpAddAccessibilityModifiersDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/AddAccessibilityModifiers/CSharpAddAccessibilityModifiersDiagnosticAnalyzer.cs
@@ -112,6 +112,7 @@ private void ProcessMemberDeclaration(
                                 return;
                             }
                         }
+
                         break;
 
                     case SyntaxKind.ClassDeclaration:
@@ -125,6 +126,7 @@ private void ProcessMemberDeclaration(
                                 return;
                             }
                         }
+
                         break;
 
                     default:
diff --git a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
index 7d5a81aba1d08..4a14e4a023573 100644
--- a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
+++ b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
@@ -95,6 +95,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UseIndexOrRangeOperator\Helpers.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseIndexOrRangeOperator\MemberInfo.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseInferredMemberName\CSharpUseInferredMemberNameDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs" />
diff --git a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx
index 086edb22c3008..72f20bb5febc9 100644
--- a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx
+++ b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx
@@ -215,6 +215,9 @@
   <data name="Use_is_null_check" xml:space="preserve">
     <value>Use 'is null' check</value>
   </data>
+  <data name="Prefer_null_check_over_type_check" xml:space="preserve">
+    <value>Prefer 'null' check over type check</value>
+  </data>
   <data name="Use_simple_using_statement" xml:space="preserve">
     <value>Use simple 'using' statement</value>
   </data>
@@ -314,4 +317,7 @@
   <data name="Blank_line_not_allowed_after_constructor_initializer_colon" xml:space="preserve">
     <value>Blank line not allowed after constructor initializer colon</value>
   </data>
+  <data name="Null_check_can_be_clarified" xml:space="preserve">
+    <value>Null check can be clarified</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs
index c56b455bfe22b..f2f06e2f86496 100644
--- a/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs
@@ -31,18 +31,21 @@ public ConvertSwitchStatementToExpressionDiagnosticAnalyzer()
         }
 
         protected override void InitializeWorker(AnalysisContext context)
-            => context.RegisterSyntaxNodeAction(AnalyzeSyntax, SyntaxKind.SwitchStatement);
+            => context.RegisterCompilationStartAction(context =>
+            {
+                if (((CSharpCompilation)context.Compilation).LanguageVersion < LanguageVersion.CSharp8)
+                {
+                    return;
+                }
+
+                context.RegisterSyntaxNodeAction(AnalyzeSyntax, SyntaxKind.SwitchStatement);
+            });
 
         private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         {
             var switchStatement = context.Node;
             var syntaxTree = switchStatement.SyntaxTree;
 
-            if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp8)
-            {
-                return;
-            }
-
             var options = context.Options;
             var cancellationToken = context.CancellationToken;
 
diff --git a/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs
index e36f80fec2c7d..a45977faac666 100644
--- a/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs
@@ -33,7 +33,9 @@ protected override bool IsValidTypeofAction(OperationAnalysisContext context)
             // Make sure that the syntax that we're looking at is actually a typeof expression and that
             // the parent syntax is a member access expression otherwise the syntax is not the kind of
             // expression that we want to analyze
-            return node is TypeOfExpressionSyntax { Parent: MemberAccessExpressionSyntax _ };
+            return node is TypeOfExpressionSyntax { Parent: MemberAccessExpressionSyntax } typeofExpression &&
+                // nameof(System.Void) isn't allowed in C#.
+                typeofExpression is not { Type: PredefinedTypeSyntax { Keyword: { RawKind: (int)SyntaxKind.VoidKeyword } } };
         }
     }
 }
diff --git a/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs
index a8fbf6b30189d..161b1405373c9 100644
--- a/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs
@@ -30,8 +30,7 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
         protected override void InitializeWorker(AnalysisContext context)
             => context.RegisterCompilationStartAction(context =>
             {
-                // All trees are expected to have the same language version. So make the check only once in compilation start .
-                if (context.Compilation.SyntaxTrees.FirstOrDefault() is SyntaxTree tree && MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(tree))
+                if (MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(((CSharpCompilation)context.Compilation).LanguageVersion))
                 {
                     context.RegisterSyntaxNodeAction(AnalyzeSyntax, SyntaxKind.LocalFunctionStatement);
                 }
diff --git a/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticHelper.cs b/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticHelper.cs
index fa231237471cb..aea838130096a 100644
--- a/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticHelper.cs
+++ b/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticHelper.cs
@@ -13,8 +13,8 @@ namespace Microsoft.CodeAnalysis.CSharp.MakeLocalFunctionStatic
 {
     internal static class MakeLocalFunctionStaticHelper
     {
-        public static bool IsStaticLocalFunctionSupported(SyntaxTree tree)
-            => tree.Options is CSharpParseOptions csharpOption && csharpOption.LanguageVersion >= LanguageVersion.CSharp8;
+        public static bool IsStaticLocalFunctionSupported(LanguageVersion languageVersion)
+            => languageVersion >= LanguageVersion.CSharp8;
 
         private static bool TryGetDataFlowAnalysis(LocalFunctionStatementSyntax localFunction, SemanticModel semanticModel, [NotNullWhen(returnValue: true)] out DataFlowAnalysis? dataFlow)
         {
diff --git a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs
index ba718ddb08926..a95e482559fd8 100644
--- a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs
@@ -2,11 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryDiscardDesignation
 {
@@ -32,15 +30,19 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
 
         protected override void InitializeWorker(AnalysisContext context)
         {
-            context.RegisterSyntaxNodeAction(AnalyzeDiscardDesignation, SyntaxKind.DiscardDesignation);
+            context.RegisterCompilationStartAction(context =>
+            {
+                if (((CSharpCompilation)context.Compilation).LanguageVersion < LanguageVersion.CSharp9)
+                {
+                    return;
+                }
+
+                context.RegisterSyntaxNodeAction(AnalyzeDiscardDesignation, SyntaxKind.DiscardDesignation);
+            });
         }
 
         private void AnalyzeDiscardDesignation(SyntaxNodeAnalysisContext context)
         {
-            var syntaxTree = context.SemanticModel.SyntaxTree;
-            if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp9)
-                return;
-
             var discard = (DiscardDesignationSyntax)context.Node;
             if (discard.Parent is DeclarationPatternSyntax)
             {
diff --git a/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs
index 8991f49e506e9..7c799f9af62d9 100644
--- a/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs
@@ -22,8 +22,8 @@ internal class CSharpUseCollectionInitializerDiagnosticAnalyzer :
             ExpressionStatementSyntax,
             VariableDeclaratorSyntax>
     {
-        protected override bool AreCollectionInitializersSupported(SyntaxNodeAnalysisContext context)
-            => ((CSharpParseOptions)context.Node.SyntaxTree.Options).LanguageVersion >= LanguageVersion.CSharp3;
+        protected override bool AreCollectionInitializersSupported(Compilation compilation)
+            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp3;
 
         protected override ISyntaxFacts GetSyntaxFacts() => CSharpSyntaxFacts.Instance;
     }
diff --git a/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseRangeOperatorDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseRangeOperatorDiagnosticAnalyzer.cs
index 50b11cb3d9911..42c6d8ca304ca 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseRangeOperatorDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseRangeOperatorDiagnosticAnalyzer.cs
@@ -82,6 +82,7 @@ private void AnalyzeInvocation(
             {
                 return;
             }
+
             context.ReportDiagnostic(CreateDiagnostic(resultOpt.Value));
         }
 
diff --git a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs
index b7b54e7ea9c99..30287bc049515 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -32,7 +30,15 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
             => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 
         protected override void InitializeWorker(AnalysisContext context)
-            => context.RegisterSyntaxNodeAction(AnalyzeSyntax, SyntaxKind.EqualsExpression, SyntaxKind.NotEqualsExpression);
+            => context.RegisterCompilationStartAction(context =>
+            {
+                if (((CSharpCompilation)context.Compilation).LanguageVersion < LanguageVersion.CSharp7)
+                {
+                    return;
+                }
+
+                context.RegisterSyntaxNodeAction(n => AnalyzeSyntax(n), SyntaxKind.EqualsExpression, SyntaxKind.NotEqualsExpression);
+            });
 
         private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         {
@@ -41,11 +47,6 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             var semanticModel = context.SemanticModel;
             var syntaxTree = semanticModel.SyntaxTree;
 
-            if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp7)
-            {
-                return;
-            }
-
             var option = context.Options.GetOption(CodeStyleOptions2.PreferIsNullCheckOverReferenceEqualityMethod, semanticModel.Language, syntaxTree, cancellationToken);
             if (!option.Value)
             {
diff --git a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs
index ea5674f5ad0cc..44bd1fca2e535 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs
@@ -17,11 +17,11 @@ public CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer()
         {
         }
 
-        protected override bool IsLanguageVersionSupported(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp7;
+        protected override bool IsLanguageVersionSupported(Compilation compilation)
+            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp7;
 
-        protected override bool IsUnconstrainedGenericSupported(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp8;
+        protected override bool IsUnconstrainedGenericSupported(Compilation compilation)
+            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp8;
 
         protected override ISyntaxFacts GetSyntaxFacts()
             => CSharpSyntaxFacts.Instance;
diff --git a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs
new file mode 100644
index 0000000000000..b0422d1feeccd
--- /dev/null
+++ b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs
@@ -0,0 +1,106 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.CSharp.UseIsNullCheck
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal sealed class CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    {
+        public CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer()
+            : base(IDEDiagnosticIds.UseNullCheckOverTypeCheckDiagnosticId,
+                   EnforceOnBuildValues.UseNullCheckOverTypeCheck,
+                   CSharpCodeStyleOptions.PreferNullCheckOverTypeCheck,
+                   CSharpAnalyzersResources.Prefer_null_check_over_type_check,
+                   new LocalizableResourceString(nameof(CSharpAnalyzersResources.Null_check_can_be_clarified), AnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)))
+        {
+        }
+
+        public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+            => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
+
+        protected override void InitializeWorker(AnalysisContext context)
+        {
+            context.RegisterCompilationStartAction(context =>
+            {
+                if (((CSharpCompilation)context.Compilation).LanguageVersion < LanguageVersion.CSharp9)
+                {
+                    return;
+                }
+
+                context.RegisterOperationAction(c => AnalyzeIsTypeOperation(c), OperationKind.IsType);
+                context.RegisterOperationAction(c => AnalyzeNegatedPatternOperation(c), OperationKind.NegatedPattern);
+            });
+        }
+
+        private static bool ShouldAnalyze(OperationAnalysisContext context, out ReportDiagnostic severity)
+        {
+            var option = context.Options.GetOption(CSharpCodeStyleOptions.PreferNullCheckOverTypeCheck, context.Operation.Syntax.SyntaxTree, context.CancellationToken);
+            if (!option.Value)
+            {
+                severity = ReportDiagnostic.Default;
+                return false;
+            }
+
+            severity = option.Notification.Severity;
+            return true;
+        }
+
+        private void AnalyzeNegatedPatternOperation(OperationAnalysisContext context)
+        {
+            if (!ShouldAnalyze(context, out var severity) ||
+                context.Operation.Syntax is not UnaryPatternSyntax)
+            {
+                return;
+            }
+
+            var negatedPattern = (INegatedPatternOperation)context.Operation;
+            // Matches 'x is not MyType'
+            // InputType is the type of 'x'
+            // MatchedType is 'MyType'
+            // We check InheritsFromOrEquals so that we report a diagnostic on the following:
+            // 1. x is not object (which is also equivalent to 'is null' check)
+            // 2. derivedObj is parentObj (which is the same as the previous point).
+            // 3. str is string (where str is a string, this is also equivalent to 'is null' check).
+            // This doesn't match `x is not MyType y` because in such case, negatedPattern.Pattern will
+            // be `DeclarationPattern`, not `TypePattern`.
+            if (negatedPattern.Pattern is ITypePatternOperation typePatternOperation &&
+                typePatternOperation.InputType.InheritsFromOrEquals(typePatternOperation.MatchedType))
+            {
+                context.ReportDiagnostic(
+                    DiagnosticHelper.Create(
+                        Descriptor, context.Operation.Syntax.GetLocation(), severity, additionalLocations: null, properties: null));
+            }
+        }
+
+        private void AnalyzeIsTypeOperation(OperationAnalysisContext context)
+        {
+            if (!ShouldAnalyze(context, out var severity) ||
+                context.Operation.Syntax is not BinaryExpressionSyntax)
+            {
+                return;
+            }
+
+            var isTypeOperation = (IIsTypeOperation)context.Operation;
+            // Matches 'x is MyType'
+            // isTypeOperation.TypeOperand is 'MyType'
+            // isTypeOperation.ValueOperand.Type is the type of 'x'.
+            // We check InheritsFromOrEquals for the same reason as stated in AnalyzeNegatedPatternOperation.
+            // This doesn't match `x is MyType y` because in such case, we have an IsPattern instead of IsType operation.
+            if (isTypeOperation.ValueOperand.Type is not null &&
+                isTypeOperation.ValueOperand.Type.InheritsFromOrEquals(isTypeOperation.TypeOperand))
+            {
+                context.ReportDiagnostic(
+                    DiagnosticHelper.Create(
+                        Descriptor, context.Operation.Syntax.GetLocation(), severity, additionalLocations: null, properties: null));
+            }
+        }
+    }
+}
diff --git a/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs
index a07f8852d5877..ed6603c859ffb 100644
--- a/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs
@@ -25,8 +25,8 @@ internal class CSharpUseNullPropagationDiagnosticAnalyzer :
             ConditionalAccessExpressionSyntax,
             ElementAccessExpressionSyntax>
     {
-        protected override bool ShouldAnalyze(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp6;
+        protected override bool ShouldAnalyze(Compilation compilation)
+            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp6;
 
         protected override ISyntaxFacts GetSyntaxFacts()
             => CSharpSyntaxFacts.Instance;
diff --git a/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs
index ad4499cee50b2..74fd38b60904b 100644
--- a/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs
@@ -23,11 +23,11 @@ internal class CSharpUseObjectInitializerDiagnosticAnalyzer :
     {
         protected override bool FadeOutOperatorToken => true;
 
-        protected override bool AreObjectInitializersSupported(SyntaxNodeAnalysisContext context)
+        protected override bool AreObjectInitializersSupported(Compilation compilation)
         {
             // object initializers are only available in C# 3.0 and above.  Don't offer this refactoring
             // in projects targeting a lesser version.
-            return ((CSharpParseOptions)context.Node.SyntaxTree.Options).LanguageVersion >= LanguageVersion.CSharp3;
+            return ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp3;
         }
 
         protected override ISyntaxFacts GetSyntaxFacts() => CSharpSyntaxFacts.Instance;
diff --git a/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpUseNotPatternDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpUseNotPatternDiagnosticAnalyzer.cs
index 193abe6b07fad..2ac35553102e6 100644
--- a/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpUseNotPatternDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpUseNotPatternDiagnosticAnalyzer.cs
@@ -40,7 +40,15 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
 
         protected override void InitializeWorker(AnalysisContext context)
         {
-            context.RegisterSyntaxNodeAction(SyntaxNodeAction, SyntaxKind.LogicalNotExpression);
+            context.RegisterCompilationStartAction(context =>
+            {
+                // "x is not Type y" is only available in C# 9.0 and above. Don't offer this refactoring
+                // in projects targeting a lesser version.
+                if (!((CSharpCompilation)context.Compilation).LanguageVersion.IsCSharp9OrAbove())
+                    return;
+
+                context.RegisterSyntaxNodeAction(n => SyntaxNodeAction(n), SyntaxKind.LogicalNotExpression);
+            });
         }
 
         private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
@@ -48,11 +56,6 @@ private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
             var node = syntaxContext.Node;
             var syntaxTree = node.SyntaxTree;
 
-            // "x is not Type y" is only available in C# 9.0 and above. Don't offer this refactoring
-            // in projects targeting a lesser version.
-            if (!((CSharpParseOptions)syntaxTree.Options).LanguageVersion.IsCSharp9OrAbove())
-                return;
-
             var options = syntaxContext.Options;
             var cancellationToken = syntaxContext.CancellationToken;
 
diff --git a/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs
index 8b1fde6a78e21..814b536e2be7d 100644
--- a/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs
@@ -20,10 +20,9 @@ public CSharpUseThrowExpressionDiagnosticAnalyzer()
         {
         }
 
-        protected override bool IsSupported(ParseOptions options)
+        protected override bool IsSupported(Compilation compilation)
         {
-            var csOptions = (CSharpParseOptions)options;
-            return csOptions.LanguageVersion >= LanguageVersion.CSharp7;
+            return ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp7;
         }
 
         protected override bool IsInExpressionTree(SemanticModel semanticModel, SyntaxNode node, INamedTypeSymbol expressionTypeOpt, CancellationToken cancellationToken)
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
index 9275c7032194a..b73204b264bb3 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
@@ -87,6 +87,16 @@
         <target state="translated">Negovat výraz (změní sémantiku)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">Odebrat operátor (zachová sémantiku)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
index 792d06259729a..b377e39861d7b 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
@@ -87,6 +87,16 @@
         <target state="translated">Ausdruck negieren (Semantik ändern)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">Operator entfernen (Semantik beibehalten)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
index 73c4553d30459..9af1e68e520c4 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
@@ -87,6 +87,16 @@
         <target state="translated">Negar expresión (cambia la semántica)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">Quitar operador (conserva la semántica)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
index e438db8ef900f..4a07c6e9c4c8e 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
@@ -87,6 +87,16 @@
         <target state="translated">Inverser l'expression (change la sémantique)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">Supprimer l'opérateur (préserve la sémantique)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
index 75364ffe50e22..fb5123f92f169 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
@@ -87,6 +87,16 @@
         <target state="translated">Nega l'espressione (modifica la semantica)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">Rimuovi l'operatore (conserva la semantica)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
index 19e1034667d43..3364db3697fb0 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
@@ -87,6 +87,16 @@
         <target state="translated">式の無効化 (セマンティクスを変更)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">演算子の削除 (セマンティクスを保持)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
index 843b32cfc965d..1f582a190e259 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
@@ -87,6 +87,16 @@
         <target state="translated">식 부정(의미 체계를 변경함)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">연산자 제거(의미 체계를 유지함)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
index e07e168532c9b..710efc1246be6 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
@@ -87,6 +87,16 @@
         <target state="translated">Neguj wyrażenie (zmienia semantykę)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">Usuń operator (zachowuje semantykę)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
index 973a6ed3437a3..71242cbf1bc71 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
@@ -87,6 +87,16 @@
         <target state="translated">Negar expressão (altera a semântica)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">Remover operador (preserva a semântica)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
index e757e4dab8da3..39eb623fa9496 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
@@ -87,6 +87,16 @@
         <target state="translated">Применить отрицание к выражению (семантика изменяется)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">Удалить оператор (семантика сохраняется)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
index 77b4cbbd66ffb..25d902af63789 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
@@ -87,6 +87,16 @@
         <target state="translated">İfadeyi tersine çevir (semantiği değiştirir)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">İşleci kaldır (semantiği korur)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
index 709577026af57..23dbf4e2b7c91 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
@@ -87,6 +87,16 @@
         <target state="translated">使用求反表达式(更改语义)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">删除运算符(保留语义)</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
index 01d387c72a704..b522c813cc10b 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
@@ -87,6 +87,16 @@
         <target state="translated">否定運算式 (變更語義)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Null_check_can_be_clarified">
+        <source>Null check can be clarified</source>
+        <target state="new">Null check can be clarified</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
         <source>Remove operator (preserves semantics)</source>
         <target state="translated">移除運算子 (保留語義)</target>
diff --git a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
index 7f2894242d7fb..5bfb9d4a7801f 100644
--- a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
+++ b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
@@ -61,6 +61,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UseInferredMemberName\CSharpUseInferredMemberNameCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\CSharpUseIsNullCheckForCastAndEqualityOperatorCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\CSharpUseIsNullCheckForReferenceEqualsCodeFixProvider.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\CSharpUseNullCheckOverTypeCheckCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseNullPropagation\CSharpUseNullPropagationCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseObjectInitializer\CSharpUseObjectInitializerCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseObjectInitializer\UseInitializerHelpers.cs" />
diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertTypeOfToNameOf/CSharpConvertTypeOfToNameOfCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/ConvertTypeOfToNameOf/CSharpConvertTypeOfToNameOfCodeFixProvider.cs
index 0c24a293d246b..3575cbc25b6ff 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertTypeOfToNameOf/CSharpConvertTypeOfToNameOfCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertTypeOfToNameOf/CSharpConvertTypeOfToNameOfCodeFixProvider.cs
@@ -30,7 +30,7 @@ protected override string GetCodeFixTitle()
             if (node is MemberAccessExpressionSyntax { Expression: TypeOfExpressionSyntax typeOfExpression })
             {
                 var typeSymbol = model.GetSymbolInfo(typeOfExpression.Type, cancellationToken).Symbol.GetSymbolType();
-                return typeSymbol?.GenerateTypeSyntax();
+                return typeSymbol?.GenerateExpressionSyntax();
             }
 
             return null;
diff --git a/src/Analyzers/CSharp/CodeFixes/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationCodeFixProvider.cs
index 73feb3cc9479e..5642f196cd1fa 100644
--- a/src/Analyzers/CSharp/CodeFixes/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationCodeFixProvider.cs
@@ -80,6 +80,7 @@ protected override Task FixAllAsync(
                                     SyntaxFactory.TypePattern(((DeclarationPatternSyntax)current).Type)
                                                  .WithAdditionalAnnotations(Formatter.Annotation));
                         }
+
                         break;
                     case RecursivePatternSyntax recursivePattern:
                         editor.ReplaceNode(
diff --git a/src/Analyzers/CSharp/CodeFixes/UseCompoundAssignment/CSharpUseCompoundAssignmentCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseCompoundAssignment/CSharpUseCompoundAssignmentCodeFixProvider.cs
index 7734fba6a5bb6..a9b93d04d5c2e 100644
--- a/src/Analyzers/CSharp/CodeFixes/UseCompoundAssignment/CSharpUseCompoundAssignmentCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UseCompoundAssignment/CSharpUseCompoundAssignmentCodeFixProvider.cs
@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.UseCompoundAssignment;
 
 namespace Microsoft.CodeAnalysis.CSharp.UseCompoundAssignment
@@ -30,14 +31,32 @@ protected override AssignmentExpressionSyntax Assignment(
             return SyntaxFactory.AssignmentExpression(assignmentOpKind, left, syntaxToken, right);
         }
 
-        protected override ExpressionSyntax Increment(ExpressionSyntax left)
-        {
-            return SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, left);
-        }
+        protected override ExpressionSyntax Increment(ExpressionSyntax left, bool postfix)
+            => postfix
+                ? Postfix(SyntaxKind.PostIncrementExpression, left)
+                : Prefix(SyntaxKind.PreIncrementExpression, left);
+
+        protected override ExpressionSyntax Decrement(ExpressionSyntax left, bool postfix)
+            => postfix
+                ? Postfix(SyntaxKind.PostDecrementExpression, left)
+                : Prefix(SyntaxKind.PreDecrementExpression, left);
 
-        protected override ExpressionSyntax Decrement(ExpressionSyntax left)
+        private static ExpressionSyntax Postfix(SyntaxKind kind, ExpressionSyntax operand)
+            => SyntaxFactory.PostfixUnaryExpression(kind, operand);
+
+        private static ExpressionSyntax Prefix(SyntaxKind kind, ExpressionSyntax operand)
+            => SyntaxFactory.PrefixUnaryExpression(kind, operand);
+
+        protected override bool PreferPostfix(ISyntaxFactsService syntaxFacts, AssignmentExpressionSyntax currentAssignment)
         {
-            return SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostDecrementExpression, left);
+            // in `for (...; x = x + 1)` we prefer to translate that idiomatically as `for (...; x++)`
+            if (currentAssignment.Parent is ForStatementSyntax forStatement &&
+                forStatement.Incrementors.Contains(currentAssignment))
+            {
+                return true;
+            }
+
+            return base.PreferPostfix(syntaxFacts, currentAssignment);
         }
     }
 }
diff --git a/src/Analyzers/CSharp/CodeFixes/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckCodeFixProvider.cs
new file mode 100644
index 0000000000000..d588e3941ec53
--- /dev/null
+++ b/src/Analyzers/CSharp/CodeFixes/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckCodeFixProvider.cs
@@ -0,0 +1,84 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
+
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace Microsoft.CodeAnalysis.CSharp.UseIsNullCheck
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.UseNullCheckOverTypeCheck), Shared]
+    internal sealed class CSharpUseNullCheckOverTypeCheckCodeFixProvider : SyntaxEditorBasedCodeFixProvider
+    {
+        private static readonly ConstantPatternSyntax s_nullConstantPattern = ConstantPattern(LiteralExpression(SyntaxKind.NullLiteralExpression));
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public CSharpUseNullCheckOverTypeCheckCodeFixProvider()
+        {
+        }
+
+        public override ImmutableArray<string> FixableDiagnosticIds
+            => ImmutableArray.Create(IDEDiagnosticIds.UseNullCheckOverTypeCheckDiagnosticId);
+
+        internal sealed override CodeFixCategory CodeFixCategory => CodeFixCategory.CodeStyle;
+
+        public override Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var diagnostic = context.Diagnostics.First();
+            context.RegisterCodeFix(
+                new MyCodeAction(c => FixAsync(context.Document, diagnostic, c)),
+                context.Diagnostics);
+
+            return Task.CompletedTask;
+        }
+
+        protected override Task FixAllAsync(
+            Document document, ImmutableArray<Diagnostic> diagnostics,
+            SyntaxEditor editor, CancellationToken cancellationToken)
+        {
+            foreach (var diagnostic in diagnostics)
+            {
+                var node = diagnostic.Location.FindNode(getInnermostNodeForTie: true, cancellationToken: cancellationToken);
+                SyntaxNode replacement = node switch
+                {
+                    // Replace 'x is object' with 'x is not null'
+                    BinaryExpressionSyntax binary =>
+                        IsPatternExpression(
+                            expression: binary.Left,
+                            pattern: UnaryPattern(s_nullConstantPattern)),
+                    UnaryPatternSyntax =>
+                        s_nullConstantPattern,
+                    // The analyzer reports diagnostic only on BinaryExpressionSyntax and UnaryPatternSyntax.
+                    _ => throw ExceptionUtilities.Unreachable
+                };
+
+                editor.ReplaceNode(node, replacement.WithTriviaFrom(node));
+            }
+
+            return Task.CompletedTask;
+        }
+
+        private class MyCodeAction : CustomCodeActions.DocumentChangeAction
+        {
+            public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
+                : base(CSharpAnalyzersResources.Prefer_null_check_over_type_check, createChangedDocument, nameof(CSharpAnalyzersResources.Prefer_null_check_over_type_check))
+            {
+            }
+        }
+    }
+}
diff --git a/src/Analyzers/CSharp/CodeFixes/UseSimpleUsingStatement/UseSimpleUsingStatementCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseSimpleUsingStatement/UseSimpleUsingStatementCodeFixProvider.cs
index b7faa6ff7e0d3..b5f0be3a94cfa 100644
--- a/src/Analyzers/CSharp/CodeFixes/UseSimpleUsingStatement/UseSimpleUsingStatementCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UseSimpleUsingStatement/UseSimpleUsingStatementCodeFixProvider.cs
@@ -163,6 +163,7 @@ private static SyntaxTriviaList Expand(List<StatementSyntax> result, UsingStatem
                     result.Add(anythingElse);
                     return default;
             }
+
             return default;
         }
 
diff --git a/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems b/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems
index 5275433d2ed3e..5e704f7d4e297 100644
--- a/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems
+++ b/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems
@@ -90,6 +90,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UseInferredMemberName\UseInferredMemberNameTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\UseIsNullCheckForCastAndEqualityOperatorTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\UseIsNullCheckForReferenceEqualsTests.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\UseNullCheckOverTypeCheckDiagnosticAnalyzerTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseExplicitTupleName\UseExplicitTupleNameTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseImplicitObjectCreation\CSharpUseImplicitObjectCreationTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseLocalFunction\UseLocalFunctionTests.cs" />
diff --git a/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfFixAllTests.cs b/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfFixAllTests.cs
index cfe4cf5773d07..9f7ef343e6e3e 100644
--- a/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfFixAllTests.cs
+++ b/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfFixAllTests.cs
@@ -2,14 +2,17 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.ConvertTypeOfToNameOf;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertTypeOfToNameOf
 {
+    using VerifyCS = CSharpCodeFixVerifier<CSharpConvertTypeOfToNameOfDiagnosticAnalyzer,
+        CSharpConvertTypeOfToNameOfCodeFixProvider>;
+
     public partial class ConvertTypeOfToNameOfTests
     {
         [Fact]
@@ -21,9 +24,9 @@ public async Task FixAllDocumentBasic()
 {
     static void Main()
     {
-        var typeName1 = {|FixAllInDocument:typeof(Test).Name|};
-        var typeName2 = typeof(Test).Name;
-        var typeName3 = typeof(Test).Name;
+        var typeName1 = [|typeof(Test).Name|];
+        var typeName2 = [|typeof(Test).Name|];
+        var typeName3 = [|typeof(Test).Name|];
     }
 }
 ";
@@ -39,7 +42,7 @@ static void Main()
 }
 ";
 
-            await TestInRegularAndScriptAsync(input, expected);
+            await VerifyCS.VerifyCodeFixAsync(input, expected);
         }
 
         [Fact]
@@ -51,7 +54,7 @@ public async Task FixAllDocumentVariedSingleLine()
 {
     static void Main()
     {
-        var typeName1 = {|FixAllInDocument:typeof(Test).Name|}; var typeName2 = typeof(int).Name; var typeName3 = typeof(System.String).Name;
+        var typeName1 = [|typeof(Test).Name|]; var typeName2 = [|typeof(int).Name|]; var typeName3 = [|typeof(System.String).Name|];
     }
 }
 ";
@@ -65,7 +68,7 @@ static void Main()
 }
 ";
 
-            await TestInRegularAndScriptAsync(input, expected);
+            await VerifyCS.VerifyCodeFixAsync(input, expected);
         }
 
         [Fact]
@@ -79,10 +82,10 @@ class Test
 {
     static void Main()
     {
-        var typeName1 = typeof(Test).Name;
-        var typeName2 = typeof(int).Name;
-        var typeName3 = typeof(String).Name;
-        var typeName4 = {|FixAllInDocument:typeof(System.Double).Name|};
+        var typeName1 = [|typeof(Test).Name|];
+        var typeName2 = [|typeof(int).Name|];
+        var typeName3 = [|typeof(String).Name|];
+        var typeName4 = [|typeof(System.Double).Name|];
     }
 }
 ";
@@ -101,7 +104,7 @@ static void Main()
 }
 ";
 
-            await TestInRegularAndScriptAsync(input, expected);
+            await VerifyCS.VerifyCodeFixAsync(input, expected);
         }
 
         [Fact]
@@ -109,41 +112,44 @@ static void Main()
         [Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
         public async Task FixAllProject()
         {
-            var input = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"
 class Test1
 {
     static void Main()
     {
-        var typeName1 = {|FixAllInProject:typeof(Test1).Name|};
-        var typeName2 = typeof(Test1).Name;
-        var typeName3 = typeof(Test1).Name;
+        var typeName1 = [|typeof(Test1).Name|];
+        var typeName2 = [|typeof(Test1).Name|];
+        var typeName3 = [|typeof(Test1).Name|];
     }
 }
-        </Document>
-        <Document>
+",
+                        @"
 using System;
 
 class Test2
 {
     static void Main()
     {
-        var typeName1 = typeof(Test1).Name;
-        var typeName2 = typeof(int).Name;
-        var typeName3 = typeof(System.String).Name;
-        var typeName4 = typeof(Double).Name;
+        var typeName1 = [|typeof(Test1).Name|];
+        var typeName2 = [|typeof(int).Name|];
+        var typeName3 = [|typeof(System.String).Name|];
+        var typeName4 = [|typeof(Double).Name|];
     }
 }
-        </Document>
-    </Project>
-</Workspace>";
-
-            var expected = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
+"
+                    }
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"
 class Test1
 {
     static void Main()
@@ -153,8 +159,8 @@ static void Main()
         var typeName3 = nameof(Test1);
     }
 }
-        </Document>
-        <Document>
+",
+                        @"
 using System;
 
 class Test2
@@ -167,11 +173,10 @@ static void Main()
         var typeName4 = nameof(Double);
     }
 }
-        </Document>
-    </Project>
-</Workspace>";
-
-            await TestInRegularAndScriptAsync(input, expected);
+",
+                    }
+                }
+            }.RunAsync();
         }
 
         [Fact]
@@ -179,52 +184,62 @@ static void Main()
         [Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
         public async Task FixAllSolution()
         {
-            var input = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"
 class Test1
 {
     static void Main()
     {
-        var typeName1 = {|FixAllInSolution:typeof(Test1).Name|};
-        var typeName2 = typeof(Test1).Name;
-        var typeName3 = typeof(Test1).Name;
+        var typeName1 = [|typeof(Test1).Name|];
+        var typeName2 = [|typeof(Test1).Name|];
+        var typeName3 = [|typeof(Test1).Name|];
     }
 }
-        </Document>
-        <Document>
+",
+                        @"
 using System;
 
 class Test2
 {
     static void Main()
     {
-        var typeName1 = typeof(Test1).Name;
-        var typeName2 = typeof(int).Name;
-        var typeName3 = typeof(System.String).Name;
-        var typeName4 = typeof(Double).Name;
+        var typeName1 = [|typeof(Test1).Name|];
+        var typeName2 = [|typeof(int).Name|];
+        var typeName3 = [|typeof(System.String).Name|];
+        var typeName4 = [|typeof(Double).Name|];
     }
 }
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <Document>
+"
+                    },
+                    AdditionalProjects =
+                    {
+                        ["DependencyProject"] =
+                        {
+                            Sources =
+                            {
+                                @"
 class Test3
 {
     static void Main()
     {
-        var typeName2 = typeof(int).Name; var typeName3 = typeof(System.String).Name;
+        var typeName2 = [|typeof(int).Name|]; var typeName3 = [|typeof(System.String).Name|];
     }
 }
-        </Document>
-    </Project>
-</Workspace>";
-
-            var expected = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
+"
+                            }
+                        }
+                    }
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"
 class Test1
 {
     static void Main()
@@ -234,8 +249,8 @@ static void Main()
         var typeName3 = nameof(Test1);
     }
 }
-        </Document>
-        <Document>
+",
+                        @"
 using System;
 
 class Test2
@@ -248,10 +263,15 @@ static void Main()
         var typeName4 = nameof(Double);
     }
 }
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <Document>
+"
+                    },
+                    AdditionalProjects =
+                    {
+                        ["DependencyProject"] =
+                        {
+                            Sources =
+                            {
+                                @"
 class Test3
 {
     static void Main()
@@ -259,11 +279,12 @@ static void Main()
         var typeName2 = nameof(System.Int32); var typeName3 = nameof(System.String);
     }
 }
-        </Document>
-    </Project>
-</Workspace>";
-
-            await TestInRegularAndScriptAsync(input, expected);
+"
+                            }
+                        }
+                    }
+                }
+            }.RunAsync();
         }
     }
 }
diff --git a/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs b/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs
index 0dce14dcf93cf..971caa0d32bfe 100644
--- a/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs
+++ b/src/Analyzers/CSharp/Tests/ConvertTypeOfToNameOf/ConvertTypeOfToNameOfTests.cs
@@ -2,29 +2,20 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.ConvertTypeOfToNameOf;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertTypeOfToNameOf
 {
-    public partial class ConvertTypeOfToNameOfTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
-    {
-        public ConvertTypeOfToNameOfTests(ITestOutputHelper logger)
-          : base(logger)
-        {
-        }
-
-        internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
-            => (new CSharpConvertTypeOfToNameOfDiagnosticAnalyzer(), new CSharpConvertTypeOfToNameOfCodeFixProvider());
+    using VerifyCS = CSharpCodeFixVerifier<CSharpConvertTypeOfToNameOfDiagnosticAnalyzer,
+        CSharpConvertTypeOfToNameOfCodeFixProvider>;
 
+    public partial class ConvertTypeOfToNameOfTests
+    {
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
         public async Task BasicType()
         {
@@ -33,7 +24,7 @@ class Test
 {
     void Method()
     {
-        var typeName = [||]typeof(Test).Name;
+        var typeName = [|typeof(Test).Name|];
     }
 }
 ";
@@ -42,11 +33,11 @@ class Test
 {
     void Method()
     {
-        var typeName = [||]nameof(Test);
+        var typeName = nameof(Test);
     }
 }
 ";
-            await TestInRegularAndScriptAsync(text, expected);
+            await VerifyCS.VerifyCodeFixAsync(text, expected);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
@@ -57,7 +48,7 @@ class Test
 {
     void Method()
     {
-        var typeName = [||]typeof(System.String).Name;
+        var typeName = [|typeof(System.String).Name|];
     }
 }
 ";
@@ -66,11 +57,11 @@ class Test
 {
     void Method()
     {
-        var typeName = [||]nameof(System.String);
+        var typeName = nameof(System.String);
     }
 }
 ";
-            await TestInRegularAndScriptAsync(text, expected);
+            await VerifyCS.VerifyCodeFixAsync(text, expected);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
@@ -83,7 +74,7 @@ class Test
 {
     void Method()
     {
-        var typeName = [||]typeof(String).Name;
+        var typeName = [|typeof(String).Name|];
     }
 }
 ";
@@ -94,43 +85,47 @@ class Test
 {
     void Method()
     {
-        var typeName = [||]nameof(String);
+        var typeName = nameof(String);
     }
 }
 ";
-            await TestInRegularAndScriptAsync(text, expected);
+            await VerifyCS.VerifyCodeFixAsync(text, expected);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
         public async Task NestedCall()
         {
             var text = @"
+using System;
+
 class Test
 {
     void Method()
     {
-        var typeName = Foo([||]typeof(System.String).Name);
+        var typeName = Foo([|typeof(System.String).Name|]);
     }
 
-    void Foo(String typeName) {
-        return;
+    int Foo(String typeName) {
+        return 0;
     }
 }
 ";
             var expected = @"
+using System;
+
 class Test
 {
     void Method()
     {
-        var typeName = Foo([||]nameof(System.String));
+        var typeName = Foo(nameof(String));
     }
 
-    void Foo(String typeName) {
-        return;
+    int Foo(String typeName) {
+        return 0;
     }
 }
 ";
-            await TestInRegularAndScriptAsync(text, expected);
+            await VerifyCS.VerifyCodeFixAsync(text, expected);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
@@ -142,12 +137,12 @@ class Test
 {
     void Method()
     {
-        var typeVar = typeof(String);[||]
+        var typeVar = typeof(String);
         var typeName = typeVar.Name;
     }
 }
 ";
-            await TestMissingInRegularAndScriptAsync(text);
+            await VerifyCS.VerifyCodeFixAsync(text, text);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
@@ -157,7 +152,7 @@ public async Task PrimitiveType()
 {
     void Method()
     {
-            var typeName = [||]typeof(int).Name;
+            var typeName = [|typeof(int).Name|];
     }
 }
 ";
@@ -165,11 +160,11 @@ void Method()
 {
     void Method()
     {
-            var typeName = [||]nameof(System.Int32);
+            var typeName = nameof(System.Int32);
     }
 }
 ";
-            await TestInRegularAndScriptAsync(text, expected);
+            await VerifyCS.VerifyCodeFixAsync(text, expected);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
@@ -181,7 +176,7 @@ class Test
 {
     void Method()
     {
-            var typeName = [||]typeof(int).Name;
+            var typeName = [|typeof(int).Name|];
     }
 }
 ";
@@ -191,11 +186,11 @@ class Test
 {
     void Method()
     {
-            var typeName = [||]nameof(Int32);
+            var typeName = nameof(Int32);
     }
 }
 ";
-            await TestInRegularAndScriptAsync(text, expected);
+            await VerifyCS.VerifyCodeFixAsync(text, expected);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
@@ -203,13 +198,13 @@ public async Task NotOnGenericType()
         {
             var text = @"class Test<T>
 {
-    void Method()[||]
+    void Method()
     {
         var typeName = typeof(T).Name;
     }
 }
 ";
-            await TestMissingInRegularAndScriptAsync(text);
+            await VerifyCS.VerifyCodeFixAsync(text, text);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
@@ -217,15 +212,15 @@ public async Task NotOnSimilarStatements()
         {
             var text = @"class Test
 {
-    void Method()[||]
+    void Method()
     {
         var typeName1 = typeof(Test);
-        var typeName2 = typeof(Test).toString();
+        var typeName2 = typeof(Test).ToString();
         var typeName3 = typeof(Test).FullName;
     }
 }
 ";
-            await TestMissingInRegularAndScriptAsync(text);
+            await VerifyCS.VerifyCodeFixAsync(text, text);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
@@ -239,13 +234,29 @@ class Bar
         { 
             void M() 
             {
-                _ = [||]typeof(Bar).Name;
+                _ = typeof(Bar).Name;
             }
         }
     }
 }
 ";
-            await TestMissingInRegularAndScriptAsync(text);
+            await VerifyCS.VerifyCodeFixAsync(text, text);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
+        [WorkItem(54233, "https://github.com/dotnet/roslyn/issues/54233")]
+        public async Task NotOnVoid()
+        {
+            var text = @"
+class C
+{
+    void M()
+    {
+        var x = typeof(void).Name;
+    }
+}
+";
+            await VerifyCS.VerifyCodeFixAsync(text, text);
         }
     }
 }
diff --git a/src/Analyzers/CSharp/Tests/UseCompoundAssignment/UseCompoundAssignmentTests.cs b/src/Analyzers/CSharp/Tests/UseCompoundAssignment/UseCompoundAssignmentTests.cs
index 65769a72b907f..e428fd8b5da3a 100644
--- a/src/Analyzers/CSharp/Tests/UseCompoundAssignment/UseCompoundAssignmentTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseCompoundAssignment/UseCompoundAssignmentTests.cs
@@ -1093,5 +1093,109 @@ void M()
     }
 }");
         }
+
+        [WorkItem(38054, "https://github.com/dotnet/roslyn/issues/53969")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseCompoundAssignment)]
+        public async Task TestIncrementInExpressionContext()
+        {
+            await TestInRegularAndScript1Async(
+@"public class C
+{
+    void M(int i)
+    {
+        M(i [||]= i + 1);
+    }
+}",
+@"public class C
+{
+    void M(int i)
+    {
+        M(++i);
+    }
+}");
+        }
+
+        [WorkItem(38054, "https://github.com/dotnet/roslyn/issues/53969")]
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUseCompoundAssignment)]
+        [InlineData("switch($$) { }")]
+        [InlineData("while(($$) > 0) { }")]
+        [InlineData("_ = true ? $$ : 0;")]
+        [InlineData("_ = ($$);")]
+        public async Task TestPrefixIncrement1(string expressionContext)
+        {
+            var before = expressionContext.Replace("$$", "i [||]= i + 1");
+            var after = expressionContext.Replace("$$", "++i");
+            await TestInRegularAndScript1Async(
+@$"public class C
+{{
+    void M(int i)
+    {{
+        {before}
+    }}
+}}",
+@$"public class C
+{{
+    void M(int i)
+    {{
+        {after}
+    }}
+}}");
+        }
+
+        [WorkItem(38054, "https://github.com/dotnet/roslyn/issues/53969")]
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUseCompoundAssignment)]
+        [InlineData("return $$;")]
+        [InlineData("return true ? $$ : 0;")]
+        [InlineData("return ($$);")]
+        public async Task TestPrefixIncrement2(string expressionContext)
+        {
+            var before = expressionContext.Replace("$$", "i [||]= i + 1");
+            var after = expressionContext.Replace("$$", "++i");
+            await TestInRegularAndScript1Async(
+@$"public class C
+{{
+    int M(int i)
+    {{
+        {before}
+    }}
+}}",
+@$"public class C
+{{
+    int M(int i)
+    {{
+        {after}
+    }}
+}}");
+        }
+
+        [WorkItem(38054, "https://github.com/dotnet/roslyn/issues/53969")]
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUseCompoundAssignment)]
+        [InlineData(
+            "/* Before */ i [||]= i + 1; /* After */",
+            "/* Before */ i++; /* After */")]
+        [InlineData(
+            "M( /* Before */ i [||]= i + 1 /* After */ );",
+            "M( /* Before */ ++i /* After */ );")]
+        [InlineData(
+            "M( /* Before */ i [||]= i - 1 /* After */ );",
+            "M( /* Before */ --i /* After */ );")]
+        public async Task TestTriviaPreserved(string before, string after)
+        {
+            await TestInRegularAndScript1Async(
+@$"public class C
+{{
+    int M(int i)
+    {{
+        {before}
+    }}
+}}",
+@$"public class C
+{{
+    int M(int i)
+    {{
+        {after}
+    }}
+}}");
+        }
     }
 }
diff --git a/src/Analyzers/CSharp/Tests/UseIsNullCheck/UseNullCheckOverTypeCheckDiagnosticAnalyzerTests.cs b/src/Analyzers/CSharp/Tests/UseIsNullCheck/UseNullCheckOverTypeCheckDiagnosticAnalyzerTests.cs
new file mode 100644
index 0000000000000..4f6ead28d789f
--- /dev/null
+++ b/src/Analyzers/CSharp/Tests/UseIsNullCheck/UseNullCheckOverTypeCheckDiagnosticAnalyzerTests.cs
@@ -0,0 +1,206 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.UseIsNullCheck;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseIsNullCheck
+{
+    using VerifyCS = CSharpCodeFixVerifier<CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer, CSharpUseNullCheckOverTypeCheckCodeFixProvider>;
+
+    [Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+    public class CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzerTests
+    {
+        private static async Task VerifyAsync(string source, string fixedSource, LanguageVersion languageVersion)
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = source,
+                FixedCode = fixedSource,
+                LanguageVersion = languageVersion,
+            }.RunAsync();
+        }
+
+        private static async Task VerifyCSharp9Async(string source, string fixedSource)
+            => await VerifyAsync(source, fixedSource, LanguageVersion.CSharp9);
+
+        private static async Task VerifyCSharp8Async(string source, string fixedSource)
+            => await VerifyAsync(source, fixedSource, LanguageVersion.CSharp8);
+
+        [Fact]
+        public async Task TestIsObjectCSharp8()
+        {
+            var source = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return value is object;
+    }
+}
+";
+            await VerifyCSharp8Async(source, source);
+        }
+
+        [Fact]
+        public async Task TestIsObject()
+        {
+            var source = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return [|value is object|]/*comment*/;
+    }
+}
+";
+            var fixedSource = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return value is not null/*comment*/;
+    }
+}
+";
+            await VerifyCSharp9Async(source, fixedSource);
+        }
+
+        [Fact]
+        public async Task TestIsObject2()
+        {
+            var source = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return value is object x;
+    }
+}
+";
+            await VerifyCSharp9Async(source, source);
+        }
+
+        [Fact]
+        public async Task TestIsNotObject()
+        {
+            var source = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return value is [|not object|];
+    }
+}
+";
+            var fixedSource = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return value is null;
+    }
+}
+";
+            await VerifyCSharp9Async(source, fixedSource);
+        }
+
+        [Fact]
+        public async Task TestIsNotObject2()
+        {
+            var source = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return value is not object o;
+    }
+}
+";
+            await VerifyCSharp9Async(source, source);
+        }
+
+        [Fact]
+        public async Task TestIsStringAgainstObject_NoDiagnostic()
+        {
+            var source = @"
+public class C
+{
+    public bool M(object value)
+    {
+        return value is string;
+    }
+}
+";
+            await VerifyCSharp9Async(source, source);
+        }
+
+        [Fact]
+        public async Task TestIsStringAgainstString()
+        {
+            var source = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return [|value is string|];
+    }
+}
+";
+            var fixedSource = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return value is not null;
+    }
+}
+";
+            await VerifyCSharp9Async(source, fixedSource);
+        }
+
+        [Fact]
+        public async Task TestIsNotStringAgainstObject_NoDiagnostic()
+        {
+            var source = @"
+public class C
+{
+    public bool M(object value)
+    {
+        return value is string;
+    }
+}
+";
+            await VerifyCSharp9Async(source, source);
+        }
+
+        [Fact]
+        public async Task TestIsNotStringAgainstString()
+        {
+            var source = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return value is [|not string|];
+    }
+}
+";
+            var fixedSource = @"
+public class C
+{
+    public bool M(string value)
+    {
+        return value is null;
+    }
+}
+";
+            await VerifyCSharp9Async(source, fixedSource);
+        }
+    }
+}
diff --git a/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs b/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs
index 6a72420de1367..4d721f4bce342 100644
--- a/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs
+++ b/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs
@@ -89,6 +89,7 @@ internal static class EnforceOnBuildValues
         public const EnforceOnBuild ConvertSwitchStatementToExpression = /*IDE0066*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild PopulateSwitchExpression = /*IDE0072*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild SimplifyLinqExpression = /*IDE0120*/ EnforceOnBuild.WhenExplicitlyEnabled;
+        public const EnforceOnBuild UseNullCheckOverTypeCheck = /*IDE0150*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild Regex = /*RE0001*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild MultipleBlankLines = /*IDE2000*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild EmbeddedStatementPlacement = /*IDE2001*/ EnforceOnBuild.WhenExplicitlyEnabled;
diff --git a/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs b/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs
index aefae585b505f..9dd78d4e0f845 100644
--- a/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs
+++ b/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs
@@ -160,6 +160,8 @@ internal static class IDEDiagnosticIds
 
         public const string SimplifyObjectCreationDiagnosticId = "IDE0140";
 
+        public const string UseNullCheckOverTypeCheckDiagnosticId = "IDE0150";
+
         // Analyzer error Ids
         public const string AnalyzerChangedId = "IDE1001";
         public const string AnalyzerDependencyConflictId = "IDE1002";
diff --git a/src/Analyzers/Core/Analyzers/NewLines/ConsecutiveStatementPlacement/AbstractConsecutiveStatementPlacementDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/NewLines/ConsecutiveStatementPlacement/AbstractConsecutiveStatementPlacementDiagnosticAnalyzer.cs
index 49cbab4cf3407..23953de87f2b0 100644
--- a/src/Analyzers/Core/Analyzers/NewLines/ConsecutiveStatementPlacement/AbstractConsecutiveStatementPlacementDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/NewLines/ConsecutiveStatementPlacement/AbstractConsecutiveStatementPlacementDiagnosticAnalyzer.cs
@@ -80,7 +80,7 @@ private void ProcessBlockLikeStatement(SyntaxTreeAnalysisContext context, Report
 
             // Grab whatever comes after the close brace.  If it's not the start of a statement, ignore it.
             var nextToken = endToken.GetNextToken();
-            var nextTokenContainingStatement = nextToken.Parent!.FirstAncestorOrSelf<TExecutableStatementSyntax>();
+            var nextTokenContainingStatement = nextToken.Parent?.FirstAncestorOrSelf<TExecutableStatementSyntax>();
             if (nextTokenContainingStatement == null)
                 return;
 
diff --git a/src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs
index 76b71f6619ed0..f38ca3a28b7d0 100644
--- a/src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs
@@ -47,6 +47,11 @@ protected override void InitializeWorker(AnalysisContext context)
 
         private void OnCompilationStart(CompilationStartAnalysisContext context)
         {
+            if (!AreCollectionInitializersSupported(context.Compilation))
+            {
+                return;
+            }
+
             var ienumerableType = context.Compilation.GetTypeByMetadataName(typeof(IEnumerable).FullName!);
             if (ienumerableType != null)
             {
@@ -57,15 +62,10 @@ private void OnCompilationStart(CompilationStartAnalysisContext context)
             }
         }
 
-        protected abstract bool AreCollectionInitializersSupported(SyntaxNodeAnalysisContext context);
+        protected abstract bool AreCollectionInitializersSupported(Compilation compilation);
 
         private void AnalyzeNode(SyntaxNodeAnalysisContext context, INamedTypeSymbol ienumerableType)
         {
-            if (!AreCollectionInitializersSupported(context))
-            {
-                return;
-            }
-
             var semanticModel = context.SemanticModel;
             var objectCreationExpression = (TObjectCreationExpressionSyntax)context.Node;
             var language = objectCreationExpression.Language;
diff --git a/src/Analyzers/Core/Analyzers/UseIsNullCheck/AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseIsNullCheck/AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs
index 7291e43a8ca6e..62530ec8162f3 100644
--- a/src/Analyzers/Core/Analyzers/UseIsNullCheck/AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseIsNullCheck/AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs
@@ -29,10 +29,10 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
             => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 
         protected override void InitializeWorker(AnalysisContext context)
-            => context.RegisterCompilationStartAction(compilationContext =>
+            => context.RegisterCompilationStartAction(context =>
             {
-                var objectType = compilationContext.Compilation.GetSpecialType(SpecialType.System_Object);
-                if (objectType != null)
+                var objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);
+                if (objectType != null && IsLanguageVersionSupported(context.Compilation))
                 {
                     var referenceEqualsMethod = objectType.GetMembers(nameof(ReferenceEquals))
                                                           .OfType<IMethodSymbol>()
@@ -41,27 +41,23 @@ protected override void InitializeWorker(AnalysisContext context)
                     if (referenceEqualsMethod != null)
                     {
                         var syntaxKinds = GetSyntaxFacts().SyntaxKinds;
+                        var unconstraintedGenericSupported = IsUnconstrainedGenericSupported(context.Compilation);
                         context.RegisterSyntaxNodeAction(
-                            c => AnalyzeSyntax(c, referenceEqualsMethod),
+                            c => AnalyzeSyntax(c, referenceEqualsMethod, unconstraintedGenericSupported),
                             syntaxKinds.Convert<TLanguageKindEnum>(syntaxKinds.InvocationExpression));
                     }
                 }
             });
 
-        protected abstract bool IsLanguageVersionSupported(ParseOptions options);
-        protected abstract bool IsUnconstrainedGenericSupported(ParseOptions options);
+        protected abstract bool IsLanguageVersionSupported(Compilation compilation);
+        protected abstract bool IsUnconstrainedGenericSupported(Compilation compilation);
         protected abstract ISyntaxFacts GetSyntaxFacts();
 
-        private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, IMethodSymbol referenceEqualsMethod)
+        private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, IMethodSymbol referenceEqualsMethod, bool unconstraintedGenericSupported)
         {
             var cancellationToken = context.CancellationToken;
 
             var semanticModel = context.SemanticModel;
-            var syntaxTree = semanticModel.SyntaxTree;
-            if (!IsLanguageVersionSupported(syntaxTree.Options))
-            {
-                return;
-            }
 
             var option = context.GetOption(CodeStyleOptions2.PreferIsNullCheckOverReferenceEqualityMethod, semanticModel.Language);
             if (!option.Value)
@@ -125,7 +121,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, IMethodSymbol refe
                 // HasReferenceTypeConstraint returns false for base type constraint.
                 // IsReferenceType returns true.
 
-                if (!genericParameterSymbol.IsReferenceType && !IsUnconstrainedGenericSupported(syntaxTree.Options))
+                if (!genericParameterSymbol.IsReferenceType && !unconstraintedGenericSupported)
                 {
                     // Needs special casing for C# as long as
                     // 'is null' over unconstrained generic is implemented in C# 8.
diff --git a/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs
index 1a43358bf74ba..ea9f9e977b8c3 100644
--- a/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs
@@ -47,7 +47,7 @@ protected AbstractUseNullPropagationDiagnosticAnalyzer()
         public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
             => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 
-        protected abstract bool ShouldAnalyze(ParseOptions options);
+        protected abstract bool ShouldAnalyze(Compilation compilation);
 
         protected abstract ISyntaxFacts GetSyntaxFacts();
         protected abstract bool IsInExpressionTree(SemanticModel semanticModel, SyntaxNode node, INamedTypeSymbol? expressionTypeOpt, CancellationToken cancellationToken);
@@ -60,6 +60,11 @@ protected override void InitializeWorker(AnalysisContext context)
         {
             context.RegisterCompilationStartAction(startContext =>
             {
+                if (!ShouldAnalyze(startContext.Compilation))
+                {
+                    return;
+                }
+
                 var expressionTypeOpt = startContext.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
 
                 var objectType = startContext.Compilation.GetSpecialType(SpecialType.System_Object);
@@ -82,10 +87,6 @@ private void AnalyzeSyntax(
             IMethodSymbol? referenceEqualsMethodOpt)
         {
             var conditionalExpression = (TConditionalExpressionSyntax)context.Node;
-            if (!ShouldAnalyze(conditionalExpression.SyntaxTree.Options))
-            {
-                return;
-            }
 
             var option = context.GetOption(CodeStyleOptions2.PreferNullPropagation, conditionalExpression.Language);
             if (!option.Value)
diff --git a/src/Analyzers/Core/Analyzers/UseObjectInitializer/AbstractUseObjectInitializerDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseObjectInitializer/AbstractUseObjectInitializerDiagnosticAnalyzer.cs
index f5289a98739af..594e19e567d0a 100644
--- a/src/Analyzers/Core/Analyzers/UseObjectInitializer/AbstractUseObjectInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseObjectInitializer/AbstractUseObjectInitializerDiagnosticAnalyzer.cs
@@ -42,21 +42,24 @@ protected AbstractUseObjectInitializerDiagnosticAnalyzer()
         protected override void InitializeWorker(AnalysisContext context)
         {
             var syntaxKinds = GetSyntaxFacts().SyntaxKinds;
-            context.RegisterSyntaxNodeAction(
-                AnalyzeNode, syntaxKinds.Convert<TSyntaxKind>(syntaxKinds.ObjectCreationExpression));
+            context.RegisterCompilationStartAction(context =>
+            {
+                if (!AreObjectInitializersSupported(context.Compilation))
+                {
+                    return;
+                }
+
+                context.RegisterSyntaxNodeAction(
+                    AnalyzeNode, syntaxKinds.Convert<TSyntaxKind>(syntaxKinds.ObjectCreationExpression));
+            });
         }
 
-        protected abstract bool AreObjectInitializersSupported(SyntaxNodeAnalysisContext context);
+        protected abstract bool AreObjectInitializersSupported(Compilation compilation);
 
         protected abstract bool IsValidContainingStatement(TStatementSyntax node);
 
         private void AnalyzeNode(SyntaxNodeAnalysisContext context)
         {
-            if (!AreObjectInitializersSupported(context))
-            {
-                return;
-            }
-
             var objectCreationExpression = (TObjectCreationExpressionSyntax)context.Node;
             var language = objectCreationExpression.Language;
             var option = context.GetOption(CodeStyleOptions2.PreferObjectInitializer, language);
diff --git a/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
index 2dd41cdd8d6a4..4b513c65bd2ee 100644
--- a/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
@@ -52,12 +52,17 @@ protected AbstractUseThrowExpressionDiagnosticAnalyzer(Option2<CodeStyleOption2<
         public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
             => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 
-        protected abstract bool IsSupported(ParseOptions options);
+        protected abstract bool IsSupported(Compilation compilation);
 
         protected override void InitializeWorker(AnalysisContext context)
         {
             context.RegisterCompilationStartAction(startContext =>
             {
+                if (!IsSupported(startContext.Compilation))
+                {
+                    return;
+                }
+
                 var expressionTypeOpt = startContext.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
                 startContext.RegisterOperationAction(operationContext => AnalyzeOperation(operationContext, expressionTypeOpt), OperationKind.Throw);
             });
@@ -65,12 +70,6 @@ protected override void InitializeWorker(AnalysisContext context)
 
         private void AnalyzeOperation(OperationAnalysisContext context, INamedTypeSymbol expressionTypeOpt)
         {
-            var syntaxTree = context.Operation.Syntax.SyntaxTree;
-            if (!IsSupported(syntaxTree.Options))
-            {
-                return;
-            }
-
             var cancellationToken = context.CancellationToken;
 
             var throwOperation = (IThrowOperation)context.Operation;
diff --git a/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs b/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs
index d5117cdd151ca..7d5d581901350 100644
--- a/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs
+++ b/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs
@@ -140,6 +140,7 @@ internal static class PredefinedCodeFixProviderNames
         public const string PopulateSwitchExpression = nameof(PopulateSwitchExpression);
         public const string UseIsNullCheckForCastAndEqualityOperator = nameof(UseIsNullCheckForCastAndEqualityOperator);
         public const string UseIsNullCheckForReferenceEquals = nameof(UseIsNullCheckForReferenceEquals);
+        public const string UseNullCheckOverTypeCheck = nameof(UseNullCheckOverTypeCheck);
         public const string UsePatternMatchingIsAndCastCheckWithoutName = nameof(UsePatternMatchingIsAndCastCheckWithoutName);
         public const string UsePatternMatchingIsAndCastCheck = nameof(UsePatternMatchingIsAndCastCheck);
         public const string UsePatternMatchingAsAndNullCheck = nameof(UsePatternMatchingAsAndNullCheck);
diff --git a/src/Analyzers/Core/CodeFixes/UseCompoundAssignment/AbstractUseCompoundAssignmentCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseCompoundAssignment/AbstractUseCompoundAssignmentCodeFixProvider.cs
index e3609df5b8128..9ef813bac5d2d 100644
--- a/src/Analyzers/Core/CodeFixes/UseCompoundAssignment/AbstractUseCompoundAssignmentCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/UseCompoundAssignment/AbstractUseCompoundAssignmentCodeFixProvider.cs
@@ -41,8 +41,8 @@ protected AbstractUseCompoundAssignmentCodeFixProvider(
         protected abstract SyntaxToken Token(TSyntaxKind kind);
         protected abstract TAssignmentSyntax Assignment(
             TSyntaxKind assignmentOpKind, TExpressionSyntax left, SyntaxToken syntaxToken, TExpressionSyntax right);
-        protected abstract TExpressionSyntax Increment(TExpressionSyntax left);
-        protected abstract TExpressionSyntax Decrement(TExpressionSyntax left);
+        protected abstract TExpressionSyntax Increment(TExpressionSyntax left, bool postfix);
+        protected abstract TExpressionSyntax Decrement(TExpressionSyntax left, bool postfix);
 
         public override Task RegisterCodeFixesAsync(CodeFixContext context)
         {
@@ -68,8 +68,11 @@ protected override Task FixAllAsync(
                 var assignment = diagnostic.AdditionalLocations[0].FindNode(getInnermostNodeForTie: true, cancellationToken);
 
                 editor.ReplaceNode(assignment,
-                    (currentAssignment, generator) =>
+                    (current, generator) =>
                     {
+                        if (current is not TAssignmentSyntax currentAssignment)
+                            return current;
+
                         syntaxFacts.GetPartsOfAssignmentExpressionOrStatement(currentAssignment,
                             out var leftOfAssign, out var equalsToken, out var rightOfAssign);
 
@@ -80,14 +83,10 @@ protected override Task FixAllAsync(
                             out _, out var opToken, out var rightExpr);
 
                         if (diagnostic.Properties.ContainsKey(UseCompoundAssignmentUtilities.Increment))
-                        {
-                            return Increment((TExpressionSyntax)leftOfAssign);
-                        }
+                            return Increment((TExpressionSyntax)leftOfAssign, PreferPostfix(syntaxFacts, currentAssignment)).WithTriviaFrom(currentAssignment);
 
                         if (diagnostic.Properties.ContainsKey(UseCompoundAssignmentUtilities.Decrement))
-                        {
-                            return Decrement((TExpressionSyntax)leftOfAssign);
-                        }
+                            return Decrement((TExpressionSyntax)leftOfAssign, PreferPostfix(syntaxFacts, currentAssignment)).WithTriviaFrom(currentAssignment);
 
                         var assignmentOpKind = _binaryToAssignmentMap[syntaxKinds.Convert<TSyntaxKind>(rightOfAssign.RawKind)];
                         var compoundOperator = Token(_assignmentToTokenMap[assignmentOpKind]);
@@ -102,6 +101,17 @@ protected override Task FixAllAsync(
             return Task.CompletedTask;
         }
 
+        protected virtual bool PreferPostfix(ISyntaxFactsService syntaxFacts, TAssignmentSyntax currentAssignment)
+        {
+            // If we have `x = x + 1;` on it's own, then we prefer `x++` as idiomatic.
+            if (syntaxFacts.IsSimpleAssignmentStatement(currentAssignment.Parent))
+                return true;
+
+            // In any other circumstance, the value of the assignment might be read, so we need to transform to
+            // ++x to ensure that we preserve semantics.
+            return false;
+        }
+
         private class MyCodeAction : CustomCodeActions.DocumentChangeAction
         {
             public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
diff --git a/src/Analyzers/VisualBasic/Analyzers/UseCollectionInitializer/VisualBasicUseCollectionInitializerDiagnosticAnalyzer.vb b/src/Analyzers/VisualBasic/Analyzers/UseCollectionInitializer/VisualBasicUseCollectionInitializerDiagnosticAnalyzer.vb
index c2989fb540790..65c1409ee484f 100644
--- a/src/Analyzers/VisualBasic/Analyzers/UseCollectionInitializer/VisualBasicUseCollectionInitializerDiagnosticAnalyzer.vb
+++ b/src/Analyzers/VisualBasic/Analyzers/UseCollectionInitializer/VisualBasicUseCollectionInitializerDiagnosticAnalyzer.vb
@@ -21,7 +21,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseCollectionInitializer
             ExpressionStatementSyntax,
             VariableDeclaratorSyntax)
 
-        Protected Overrides Function AreCollectionInitializersSupported(context As SyntaxNodeAnalysisContext) As Boolean
+        Protected Overrides Function AreCollectionInitializersSupported(compilation As Compilation) As Boolean
             Return True
         End Function
 
diff --git a/src/Analyzers/VisualBasic/Analyzers/UseIsNullCheck/VisualBasicUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.vb b/src/Analyzers/VisualBasic/Analyzers/UseIsNullCheck/VisualBasicUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.vb
index d9e5b5be74811..f528c0a7aa400 100644
--- a/src/Analyzers/VisualBasic/Analyzers/UseIsNullCheck/VisualBasicUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.vb
+++ b/src/Analyzers/VisualBasic/Analyzers/UseIsNullCheck/VisualBasicUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.vb
@@ -16,11 +16,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseIsNullCheck
             MyBase.New(VisualBasicAnalyzersResources.Use_Is_Nothing_check)
         End Sub
 
-        Protected Overrides Function IsLanguageVersionSupported(options As ParseOptions) As Boolean
+        Protected Overrides Function IsLanguageVersionSupported(compilation As Compilation) As Boolean
             Return True
         End Function
 
-        Protected Overrides Function IsUnconstrainedGenericSupported(options As ParseOptions) As Boolean
+        Protected Overrides Function IsUnconstrainedGenericSupported(compilation As Compilation) As Boolean
             Return True
         End Function
 
diff --git a/src/Analyzers/VisualBasic/Analyzers/UseNullPropagation/VisualBasicUseNullPropagationDiagnosticAnalyzer.vb b/src/Analyzers/VisualBasic/Analyzers/UseNullPropagation/VisualBasicUseNullPropagationDiagnosticAnalyzer.vb
index f016303bd7d38..925ce785b3e2b 100644
--- a/src/Analyzers/VisualBasic/Analyzers/UseNullPropagation/VisualBasicUseNullPropagationDiagnosticAnalyzer.vb
+++ b/src/Analyzers/VisualBasic/Analyzers/UseNullPropagation/VisualBasicUseNullPropagationDiagnosticAnalyzer.vb
@@ -22,8 +22,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseNullPropagation
             ConditionalAccessExpressionSyntax,
             InvocationExpressionSyntax)
 
-        Protected Overrides Function ShouldAnalyze(options As ParseOptions) As Boolean
-            Return DirectCast(options, VisualBasicParseOptions).LanguageVersion >= LanguageVersion.VisualBasic14
+        Protected Overrides Function ShouldAnalyze(compilation As Compilation) As Boolean
+            Return DirectCast(compilation, VisualBasicCompilation).LanguageVersion >= LanguageVersion.VisualBasic14
         End Function
 
         Protected Overrides Function GetSyntaxFacts() As ISyntaxFacts
diff --git a/src/Analyzers/VisualBasic/Analyzers/UseObjectInitializer/VisualBasicUseObjectInitializerDiagnosticAnalyzer.vb b/src/Analyzers/VisualBasic/Analyzers/UseObjectInitializer/VisualBasicUseObjectInitializerDiagnosticAnalyzer.vb
index 5f5dad08c996d..73088cd3cec6d 100644
--- a/src/Analyzers/VisualBasic/Analyzers/UseObjectInitializer/VisualBasicUseObjectInitializerDiagnosticAnalyzer.vb
+++ b/src/Analyzers/VisualBasic/Analyzers/UseObjectInitializer/VisualBasicUseObjectInitializerDiagnosticAnalyzer.vb
@@ -26,7 +26,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseObjectInitializer
             End Get
         End Property
 
-        Protected Overrides Function AreObjectInitializersSupported(context As SyntaxNodeAnalysisContext) As Boolean
+        Protected Overrides Function AreObjectInitializersSupported(compilation As Compilation) As Boolean
             'Object Initializers are supported in all the versions of Visual Basic we support
             Return True
         End Function
diff --git a/src/Analyzers/VisualBasic/CodeFixes/RemoveUnnecessaryByVal/VisualBasicRemoveUnnecessaryByValCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/RemoveUnnecessaryByVal/VisualBasicRemoveUnnecessaryByValCodeFixProvider.vb
index a4dbab38f70eb..3df6572f0ffd1 100644
--- a/src/Analyzers/VisualBasic/CodeFixes/RemoveUnnecessaryByVal/VisualBasicRemoveUnnecessaryByValCodeFixProvider.vb
+++ b/src/Analyzers/VisualBasic/CodeFixes/RemoveUnnecessaryByVal/VisualBasicRemoveUnnecessaryByValCodeFixProvider.vb
@@ -35,6 +35,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.RemoveUnnecessaryByVal
                     Function(ct) FixAsync(context.Document, diagnostic, ct)),
                     diagnostic)
             Next
+
             Return Task.CompletedTask
         End Function
 
diff --git a/src/Analyzers/VisualBasic/CodeFixes/SimplifyObjectCreation/VisualBasicSimplifyObjectCreationCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/SimplifyObjectCreation/VisualBasicSimplifyObjectCreationCodeFixProvider.vb
index dc95518148ff1..caf3cc969f0c6 100644
--- a/src/Analyzers/VisualBasic/CodeFixes/SimplifyObjectCreation/VisualBasicSimplifyObjectCreationCodeFixProvider.vb
+++ b/src/Analyzers/VisualBasic/CodeFixes/SimplifyObjectCreation/VisualBasicSimplifyObjectCreationCodeFixProvider.vb
@@ -33,6 +33,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.SimplifyObjectCreation
                     Function(ct) FixAsync(context.Document, diagnostic, ct)),
                     diagnostic)
             Next
+
             Return Task.CompletedTask
         End Function
 
diff --git a/src/Analyzers/VisualBasic/CodeFixes/UseCompoundAssignment/VisualBasicUseCompoundAssignmentCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/UseCompoundAssignment/VisualBasicUseCompoundAssignmentCodeFixProvider.vb
index 4848d738e4558..578a8bbd85a35 100644
--- a/src/Analyzers/VisualBasic/CodeFixes/UseCompoundAssignment/VisualBasicUseCompoundAssignmentCodeFixProvider.vb
+++ b/src/Analyzers/VisualBasic/CodeFixes/UseCompoundAssignment/VisualBasicUseCompoundAssignmentCodeFixProvider.vb
@@ -30,11 +30,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseCompoundAssignment
             Return SyntaxFactory.AssignmentStatement(assignmentOpKind, left, syntaxToken, right)
         End Function
 
-        Protected Overrides Function Increment(left As ExpressionSyntax) As ExpressionSyntax
+        Protected Overrides Function Increment(left As ExpressionSyntax, postfix As Boolean) As ExpressionSyntax
             Throw ExceptionUtilities.Unreachable
         End Function
 
-        Protected Overrides Function Decrement(left As ExpressionSyntax) As ExpressionSyntax
+        Protected Overrides Function Decrement(left As ExpressionSyntax, postfix As Boolean) As ExpressionSyntax
             Throw ExceptionUtilities.Unreachable
         End Function
     End Class
diff --git a/src/Analyzers/VisualBasic/Tests/ConvertGetTypeToNameOf/ConvertGetTypeToNameOfTests.vb b/src/Analyzers/VisualBasic/Tests/ConvertGetTypeToNameOf/ConvertGetTypeToNameOfTests.vb
index b10e25dff9c26..d69c5b315c44a 100644
--- a/src/Analyzers/VisualBasic/Tests/ConvertGetTypeToNameOf/ConvertGetTypeToNameOfTests.vb
+++ b/src/Analyzers/VisualBasic/Tests/ConvertGetTypeToNameOf/ConvertGetTypeToNameOfTests.vb
@@ -2,36 +2,29 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
-Imports Microsoft.CodeAnalysis.CodeFixes
-Imports Microsoft.CodeAnalysis.Diagnostics
-Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics
-Imports Microsoft.CodeAnalysis.VisualBasic.ConvertTypeOfToNameOf
+Imports VerifyVB = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.VisualBasicCodeFixVerifier(Of
+    Microsoft.CodeAnalysis.VisualBasic.ConvertTypeOfToNameOf.VisualBasicConvertTypeOfToNameOfDiagnosticAnalyzer,
+    Microsoft.CodeAnalysis.VisualBasic.ConvertTypeOfToNameOf.VisualBasicConvertGetTypeToNameOfCodeFixProvider)
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ConvertGetTypeToNameOf
     Partial Public Class ConvertGetTypeToNameOfTests
-        Inherits AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest
-
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace) As (DiagnosticAnalyzer, CodeFixProvider)
-            Return (New VisualBasicConvertTypeOfToNameOfDiagnosticAnalyzer(), New VisualBasicConvertGetTypeToNameOfCodeFixProvider())
-        End Function
-
         <Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)>
         Public Async Function BasicType() As Task
             Dim text = "
 class Test
     sub Method()
-        dim typeName = [||]GetType(Test).Name
+        dim typeName = [|GetType(Test).Name|]
     end sub
 end class
 "
             Dim expected = "
 class Test
     sub Method()
-        dim typeName = [||]NameOf(Test)
+        dim typeName = NameOf(Test)
     end sub
 end class
 "
-            Await TestInRegularAndScriptAsync(text, expected)
+            Await VerifyVB.VerifyCodeFixAsync(text, expected)
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)>
@@ -39,18 +32,18 @@ end class
             Dim text = "
 class Test
     sub Method()
-        dim typeName = [||]GetType(System.String).Name
+        dim typeName = [|GetType(System.String).Name|]
     end sub
 end class
 "
             Dim expected = "
 class Test
     sub Method()
-        dim typeName = [||]NameOf(System.String)
+        dim typeName = NameOf(System.String)
     end sub
 end class
 "
-            Await TestInRegularAndScriptAsync(text, expected)
+            Await VerifyVB.VerifyCodeFixAsync(text, expected)
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)>
@@ -60,7 +53,7 @@ Imports System
 
 class Test
     sub Method()
-        dim typeName = [||]GetType(String).Name
+        dim typeName = [|GetType(String).Name|]
     end sub
 end class
 "
@@ -69,11 +62,11 @@ Imports System
 
 class Test
     sub Method()
-        dim typeName = [||]NameOf([String])
+        dim typeName = NameOf([String])
     end sub
 end class
 "
-            Await TestInRegularAndScriptAsync(text, expected)
+            Await VerifyVB.VerifyCodeFixAsync(text, expected)
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)>
@@ -83,11 +76,11 @@ Imports System
 
 class Test
     sub Method()
-        dim typeName = Foo([||]GetType(String).Name)
+        dim typeName = Goo([|GetType(String).Name|])
     end sub
 
-    sub Foo(ByVal typeName As String)
-    end sub
+    function Goo(ByVal typeName As String) As Integer
+    end function
 end class
 "
             Dim expected = "
@@ -95,29 +88,53 @@ Imports System
 
 class Test
     sub Method()
-        dim typeName = Foo([||]NameOf([String]))
+        dim typeName = Goo(NameOf([String]))
     end sub
 
-    sub Foo(ByVal typeName As String)
-    end sub
+    function Goo(ByVal typeName As String) As Integer
+    end function
 end class
 "
-            Await TestInRegularAndScriptAsync(text, expected)
+            Await VerifyVB.VerifyCodeFixAsync(text, expected)
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertAnonymousTypeToTuple)>
         Public Async Function NotOnVariableContainingType() As Task
-            Await TestMissingInRegularAndScriptAsync("
-import System
+            Dim text = "
+imports System
 
 class Test
     sub Method()
-        dim typeVar = [||]GetType(String)
+        dim typeVar = GetType(String)
         dim typeName = typeVar.Name 
     end sub
 end class
-")
+"
+            Await VerifyVB.VerifyCodeFixAsync(text, text)
         End Function
 
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertAnonymousTypeToTuple)>
+        <WorkItem(54233, "https://github.com/dotnet/roslyn/issues/54233")>
+        Public Async Function OnVoid() As Task
+            Dim text = "
+imports System
+
+class Test
+    sub Method()
+        dim typeVar = [|GetType(Void).Name|]
+    end sub
+end class
+"
+            Dim expected = "
+imports System
+
+class Test
+    sub Method()
+        dim typeVar = NameOf(Void)
+    end sub
+end class
+"
+            Await VerifyVB.VerifyCodeFixAsync(text, expected)
+        End Function
     End Class
 End Namespace
diff --git a/src/Analyzers/VisualBasic/Tests/NewLines/ConsecutiveStatementPlacement/ConsecutiveStatementPlacementTests.vb b/src/Analyzers/VisualBasic/Tests/NewLines/ConsecutiveStatementPlacement/ConsecutiveStatementPlacementTests.vb
index 8308bc5416595..da17fb0a082eb 100644
--- a/src/Analyzers/VisualBasic/Tests/NewLines/ConsecutiveStatementPlacement/ConsecutiveStatementPlacementTests.vb
+++ b/src/Analyzers/VisualBasic/Tests/NewLines/ConsecutiveStatementPlacement/ConsecutiveStatementPlacementTests.vb
@@ -431,5 +431,17 @@ class C
     end sub
 end class")
         End Function
+
+        <Fact>
+        Public Async Function TestClassWithEndOfLine() As Task
+            Dim code = "
+class C
+    sub M()
+    end sub
+end class
+"
+
+            Await TestWithOptionOn(code, code)
+        End Function
     End Class
 End Namespace
diff --git a/src/CodeStyle/CSharp/Tests/FormattingAnalyzerTests.cs b/src/CodeStyle/CSharp/Tests/FormattingAnalyzerTests.cs
index 96f2902a56a38..d078794b7f5e8 100644
--- a/src/CodeStyle/CSharp/Tests/FormattingAnalyzerTests.cs
+++ b/src/CodeStyle/CSharp/Tests/FormattingAnalyzerTests.cs
@@ -270,16 +270,15 @@ void MyMethod()
 
             await new CSharpCodeFixTest<CSharpFormattingAnalyzer, CSharpFormattingCodeFixProvider, XUnitVerifier>
             {
-                TestState = { Sources = { (Path.GetFullPath("Test0.cs"), testCode) } },
-                FixedState = { Sources = { (Path.GetFullPath("Test0.cs"), fixedCode) } },
-                SolutionTransforms =
+                TestState =
                 {
-                    (solution, projectId) =>
+                    Sources = { testCode },
+                    AnalyzerConfigFiles =
                     {
-                        var documentId = DocumentId.CreateNewId(projectId, ".editorconfig");
-                        return solution.AddAnalyzerConfigDocument(documentId, ".editorconfig", SourceText.From(editorConfig, Encoding.UTF8), filePath: Path.GetFullPath(".editorconfig"));
+                        ("/.editorconfig", editorConfig),
                     },
                 },
+                FixedState = { Sources = { fixedCode } },
             }.RunAsync();
         }
     }
diff --git a/src/CodeStyle/Core/Tests/Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities.csproj b/src/CodeStyle/Core/Tests/Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities.csproj
index 9cb5c77e650de..dae2461a112e8 100644
--- a/src/CodeStyle/Core/Tests/Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities.csproj
+++ b/src/CodeStyle/Core/Tests/Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities.csproj
@@ -16,6 +16,7 @@
     <Compile Include="..\..\..\EditorFeatures\DiagnosticsTestUtilities\CodeActions\CSharpCodeRefactoringVerifier`1+Test.cs" Link="CSharpCodeRefactoringVerifier`1+Test.cs" />
     <Compile Include="..\..\..\EditorFeatures\DiagnosticsTestUtilities\CodeActions\CSharpCodeRefactoringVerifier`1.cs" Link="CSharpCodeRefactoringVerifier`1.cs" />
     <Compile Include="..\..\..\EditorFeatures\DiagnosticsTestUtilities\CodeActions\CSharpVerifierHelper.cs" Link="CSharpVerifierHelper.cs" />
+    <Compile Include="..\..\..\EditorFeatures\DiagnosticsTestUtilities\CodeActions\SharedVerifierState.cs" Link="SharedVerifierState.cs" />
     <Compile Include="..\..\..\EditorFeatures\DiagnosticsTestUtilities\CodeActions\VisualBasicCodeFixVerifier`2+Test.cs" Link="VisualBasicCodeFixVerifier`2+Test.cs" />
     <Compile Include="..\..\..\EditorFeatures\DiagnosticsTestUtilities\CodeActions\VisualBasicCodeFixVerifier`2.cs" Link="VisualBasicCodeFixVerifier`2.cs" />
     <Compile Include="..\..\..\EditorFeatures\DiagnosticsTestUtilities\CodeActions\VisualBasicCodeRefactoringVerifier`1+Test.cs" Link="VisualBasicCodeRefactoringVerifier`1+Test.cs" />
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder.QueryUnboundLambdaState.cs b/src/Compilers/CSharp/Portable/Binder/Binder.QueryUnboundLambdaState.cs
index f81b856f417dc..b750043fad8c2 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder.QueryUnboundLambdaState.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder.QueryUnboundLambdaState.cs
@@ -35,6 +35,14 @@ public QueryUnboundLambdaState(Binder binder, RangeVariableMap rangeVariableMap,
             public override SyntaxList<AttributeListSyntax> ParameterAttributes(int index) => default;
             public override bool HasNames { get { return true; } }
             public override bool HasSignature { get { return true; } }
+
+            public override bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType)
+            {
+                refKind = default;
+                returnType = default;
+                return false;
+            }
+
             public override bool HasExplicitlyTypedParameterList { get { return false; } }
             public override int ParameterCount { get { return _parameters.Length; } }
             public override bool IsAsync { get { return false; } }
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs b/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs
index 3b0fa25679896..dbba1849b977e 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs
@@ -1133,7 +1133,7 @@ private bool CheckPropertyValueKind(SyntaxNode node, BoundExpression expr, BindV
                         return false;
                     }
 
-                    CheckRuntimeSupportForSymbolAccess(node, receiver, setMethod, diagnostics);
+                    CheckReceiverAndRuntimeSupportForSymbolAccess(node, receiver, setMethod, diagnostics);
                 }
             }
 
@@ -1177,7 +1177,7 @@ private bool CheckPropertyValueKind(SyntaxNode node, BoundExpression expr, BindV
                         return false;
                     }
 
-                    CheckRuntimeSupportForSymbolAccess(node, receiver, getMethod, diagnostics);
+                    CheckReceiverAndRuntimeSupportForSymbolAccess(node, receiver, getMethod, diagnostics);
                 }
             }
 
diff --git a/src/Compilers/CSharp/Portable/Binder/BinderFactory.BinderFactoryVisitor.cs b/src/Compilers/CSharp/Portable/Binder/BinderFactory.BinderFactoryVisitor.cs
index 447f53cfd1556..ac2e06add3d45 100644
--- a/src/Compilers/CSharp/Portable/Binder/BinderFactory.BinderFactoryVisitor.cs
+++ b/src/Compilers/CSharp/Portable/Binder/BinderFactory.BinderFactoryVisitor.cs
@@ -448,11 +448,11 @@ private static string GetMethodName(BaseMethodDeclarationSyntax baseMethodDeclar
                     case SyntaxKind.DestructorDeclaration:
                         return WellKnownMemberNames.DestructorName;
                     case SyntaxKind.OperatorDeclaration:
-                        return OperatorFacts.OperatorNameFromDeclaration((OperatorDeclarationSyntax)baseMethodDeclarationSyntax);
+                        var operatorDeclaration = (OperatorDeclarationSyntax)baseMethodDeclarationSyntax;
+                        return ExplicitInterfaceHelpers.GetMemberName(outerBinder, operatorDeclaration.ExplicitInterfaceSpecifier, OperatorFacts.OperatorNameFromDeclaration(operatorDeclaration));
                     case SyntaxKind.ConversionOperatorDeclaration:
-                        return ((ConversionOperatorDeclarationSyntax)baseMethodDeclarationSyntax).ImplicitOrExplicitKeyword.Kind() == SyntaxKind.ImplicitKeyword
-                            ? WellKnownMemberNames.ImplicitConversionName
-                            : WellKnownMemberNames.ExplicitConversionName;
+                        var conversionDeclaration = (ConversionOperatorDeclarationSyntax)baseMethodDeclarationSyntax;
+                        return ExplicitInterfaceHelpers.GetMemberName(outerBinder, conversionDeclaration.ExplicitInterfaceSpecifier, OperatorFacts.OperatorNameFromDeclaration(conversionDeclaration));
                     case SyntaxKind.MethodDeclaration:
                         MethodDeclarationSyntax methodDeclSyntax = (MethodDeclarationSyntax)baseMethodDeclarationSyntax;
                         return ExplicitInterfaceHelpers.GetMemberName(outerBinder, methodDeclSyntax.ExplicitInterfaceSpecifier, methodDeclSyntax.Identifier.ValueText);
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
index 63fb97b106ec1..a4555b2a11018 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
@@ -90,6 +90,7 @@ protected BoundExpression CreateConversion(
 
             // Obsolete diagnostics for method group are reported as part of creating the method group conversion.
             ReportDiagnosticsIfObsolete(diagnostics, conversion, syntax, hasBaseReceiver: false);
+            CheckConstraintLanguageVersionAndRuntimeSupportForConversion(syntax, conversion, diagnostics);
 
             if (conversion.IsAnonymousFunction && source.Kind == BoundKind.UnboundLambda)
             {
@@ -229,6 +230,25 @@ protected BoundExpression CreateConversion(
             { WasCompilerGenerated = wasCompilerGenerated };
         }
 
+        internal void CheckConstraintLanguageVersionAndRuntimeSupportForConversion(SyntaxNodeOrToken syntax, Conversion conversion, BindingDiagnosticBag diagnostics)
+        {
+            if (conversion.IsUserDefined && conversion.Method is MethodSymbol method && method.IsStatic && method.IsAbstract)
+            {
+                Debug.Assert(conversion.ConstrainedToTypeOpt is TypeParameterSymbol);
+
+                if (Compilation.SourceModule != method.ContainingModule)
+                {
+                    Debug.Assert(syntax.SyntaxTree is object);
+                    CheckFeatureAvailability(syntax.SyntaxTree, MessageID.IDS_FeatureStaticAbstractMembersInInterfaces, diagnostics, syntax.GetLocation()!);
+
+                    if (!Compilation.Assembly.RuntimeSupportsStaticAbstractMembersInInterfaces)
+                    {
+                        Error(diagnostics, ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, syntax);
+                    }
+                }
+            }
+        }
+
         private BoundExpression ConvertObjectCreationExpression(SyntaxNode syntax, BoundUnconvertedObjectCreationExpression node, bool isCast, TypeSymbol destination, BindingDiagnosticBag diagnostics)
         {
             var arguments = AnalyzedArguments.GetInstance(node.Arguments, node.ArgumentRefKindsOpt, node.ArgumentNamesOpt);
@@ -334,11 +354,13 @@ private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression
             for (int i = 0, n = source.SwitchArms.Length; i < n; i++)
             {
                 var oldCase = source.SwitchArms[i];
+                Debug.Assert(oldCase.Syntax is SwitchExpressionArmSyntax);
+                var binder = GetRequiredBinder(oldCase.Syntax);
                 var oldValue = oldCase.Value;
                 var newValue =
                     targetTyped
-                    ? CreateConversion(oldValue.Syntax, oldValue, underlyingConversions[i], isCast: false, conversionGroupOpt: null, destination, diagnostics)
-                    : GenerateConversionForAssignment(destination, oldValue, diagnostics);
+                    ? binder.CreateConversion(oldValue.Syntax, oldValue, underlyingConversions[i], isCast: false, conversionGroupOpt: null, destination, diagnostics)
+                    : binder.GenerateConversionForAssignment(destination, oldValue, diagnostics);
                 var newCase = (oldValue == newValue) ? oldCase :
                     new BoundSwitchExpressionArm(oldCase.Syntax, oldCase.Locals, oldCase.Pattern, oldCase.WhenClause, newValue, oldCase.Label, oldCase.HasErrors);
                 builder.Add(newCase);
@@ -361,6 +383,7 @@ private BoundExpression CreateUserDefinedConversion(
             bool hasErrors)
         {
             Debug.Assert(conversionGroup != null);
+            Debug.Assert(conversion.IsUserDefined);
 
             if (!conversion.IsValid)
             {
@@ -803,7 +826,7 @@ private bool MemberGroupFinalValidation(BoundExpression? receiverOpt, MethodSymb
         {
             if (!IsBadBaseAccess(node, receiverOpt, methodSymbol, diagnostics))
             {
-                CheckRuntimeSupportForSymbolAccess(node, receiverOpt, methodSymbol, diagnostics);
+                CheckReceiverAndRuntimeSupportForSymbolAccess(node, receiverOpt, methodSymbol, diagnostics);
             }
 
             if (MemberGroupFinalValidationAccessibilityChecks(receiverOpt, methodSymbol, node, diagnostics, invokedAsExtensionMethod))
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Crefs.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Crefs.cs
index 76b0ec981fadc..ca1a59451baf1 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Crefs.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Crefs.cs
@@ -757,6 +757,7 @@ private static ImmutableArray<Symbol> PerformCrefOverloadResolution(ArrayBuilder
                                 name: null,
                                 refKind: RefKind.None,
                                 isInitOnly: false,
+                                isStatic: false,
                                 returnType: default,
                                 refCustomModifiers: ImmutableArray<CustomModifier>.Empty,
                                 explicitInterfaceImplementations: ImmutableArray<MethodSymbol>.Empty);
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index 5c8ab422a7f2d..e3b9bf1aa121d 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -6111,8 +6111,7 @@ private BoundExpression BindMemberAccessWithBoundLeft(
                 }
 
                 var typeArgumentsSyntax = right.Kind() == SyntaxKind.GenericName ? ((GenericNameSyntax)right).TypeArgumentList.Arguments : default(SeparatedSyntaxList<TypeSyntax>);
-                bool rightHasTypeArguments = typeArgumentsSyntax.Count > 0;
-                var typeArguments = rightHasTypeArguments ? BindTypeArguments(typeArgumentsSyntax, diagnostics) : default(ImmutableArray<TypeWithAnnotations>);
+                var typeArguments = typeArgumentsSyntax.Count > 0 ? BindTypeArguments(typeArgumentsSyntax, diagnostics) : default(ImmutableArray<TypeWithAnnotations>);
 
                 // A member-access consists of a primary-expression, a predefined-type, or a 
                 // qualified-alias-member, followed by a "." token, followed by an identifier, 
@@ -6134,91 +6133,28 @@ private BoundExpression BindMemberAccessWithBoundLeft(
 
                 var rightName = right.Identifier.ValueText;
                 var rightArity = right.Arity;
+                BoundExpression result;
 
                 switch (boundLeft.Kind)
                 {
                     case BoundKind.NamespaceExpression:
                         {
-                            // If K is zero and E is a namespace and E contains a nested namespace with name I, 
-                            // then the result is that namespace.
-
-                            var ns = ((BoundNamespaceExpression)boundLeft).NamespaceSymbol;
-                            CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-                            this.LookupMembersWithFallback(lookupResult, ns, rightName, rightArity, ref useSiteInfo, options: options);
-                            diagnostics.Add(right, useSiteInfo);
-
-                            ArrayBuilder<Symbol> symbols = lookupResult.Symbols;
-
-                            if (lookupResult.IsMultiViable)
+                            result = tryBindMemberAccessWithBoundNamespaceLeft(((BoundNamespaceExpression)boundLeft).NamespaceSymbol, node, boundLeft, right, diagnostics, lookupResult, options, typeArgumentsSyntax, typeArguments, rightName, rightArity);
+                            if (result is object)
                             {
-                                bool wasError;
-                                Symbol sym = ResultSymbol(lookupResult, rightName, rightArity, node, diagnostics, false, out wasError, ns, options);
-                                if (wasError)
-                                {
-                                    return new BoundBadExpression(node, LookupResultKind.Ambiguous, lookupResult.Symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true);
-                                }
-                                else if (sym.Kind == SymbolKind.Namespace)
-                                {
-                                    return new BoundNamespaceExpression(node, (NamespaceSymbol)sym);
-                                }
-                                else
-                                {
-                                    Debug.Assert(sym.Kind == SymbolKind.NamedType);
-                                    var type = (NamedTypeSymbol)sym;
-
-                                    if (rightHasTypeArguments)
-                                    {
-                                        type = ConstructNamedTypeUnlessTypeArgumentOmitted(right, type, typeArgumentsSyntax, typeArguments, diagnostics);
-                                    }
-
-                                    ReportDiagnosticsIfObsolete(diagnostics, type, node, hasBaseReceiver: false);
-
-                                    return new BoundTypeExpression(node, null, type);
-                                }
+                                return result;
                             }
-                            else if (lookupResult.Kind == LookupResultKind.WrongArity)
-                            {
-                                Debug.Assert(symbols.Count > 0);
-                                Debug.Assert(symbols[0].Kind == SymbolKind.NamedType);
-
-                                Error(diagnostics, lookupResult.Error, right);
-
-                                return new BoundTypeExpression(node, null,
-                                            new ExtendedErrorTypeSymbol(GetContainingNamespaceOrType(symbols[0]), symbols.ToImmutable(), lookupResult.Kind, lookupResult.Error, rightArity));
-                            }
-                            else if (lookupResult.Kind == LookupResultKind.Empty)
-                            {
-                                Debug.Assert(lookupResult.IsClear, "If there's a legitimate reason for having candidates without a reason, then we should produce something intelligent in such cases.");
-                                Debug.Assert(lookupResult.Error == null);
-                                NotFound(node, rightName, rightArity, rightName, diagnostics, aliasOpt: null, qualifierOpt: ns, options: options);
 
-                                return new BoundBadExpression(node, lookupResult.Kind, symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true);
-                            }
                             break;
                         }
                     case BoundKind.TypeExpression:
                         {
-                            Debug.Assert((object)leftType != null);
-                            if (leftType.TypeKind == TypeKind.TypeParameter)
-                            {
-                                Error(diagnostics, ErrorCode.ERR_BadSKunknown, boundLeft.Syntax, leftType, MessageID.IDS_SK_TYVAR.Localize());
-                                return BadExpression(node, LookupResultKind.NotAValue, boundLeft);
-                            }
-                            else if (this.EnclosingNameofArgument == node)
-                            {
-                                // Support selecting an extension method from a type name in nameof(.)
-                                return BindInstanceMemberAccess(node, right, boundLeft, rightName, rightArity, typeArgumentsSyntax, typeArguments, invoked, indexed, diagnostics);
-                            }
-                            else
+                            result = tryBindMemberAccessWithBoundTypeLeft(node, boundLeft, right, invoked, indexed, diagnostics, leftType, lookupResult, options, typeArgumentsSyntax, typeArguments, rightName, rightArity);
+                            if (result is object)
                             {
-                                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-                                this.LookupMembersWithFallback(lookupResult, leftType, rightName, rightArity, ref useSiteInfo, basesBeingResolved: null, options: options);
-                                diagnostics.Add(right, useSiteInfo);
-                                if (lookupResult.IsMultiViable)
-                                {
-                                    return BindMemberOfType(node, right, rightName, rightArity, indexed, boundLeft, typeArgumentsSyntax, typeArguments, lookupResult, BoundMethodGroupFlags.None, diagnostics: diagnostics);
-                                }
+                                return result;
                             }
+
                             break;
                         }
                     case BoundKind.TypeOrValueExpression:
@@ -6260,6 +6196,130 @@ private BoundExpression BindMemberAccessWithBoundLeft(
             {
                 lookupResult.Free();
             }
+
+            [MethodImpl(MethodImplOptions.NoInlining)]
+            BoundExpression tryBindMemberAccessWithBoundNamespaceLeft(
+                NamespaceSymbol ns,
+                ExpressionSyntax node,
+                BoundExpression boundLeft,
+                SimpleNameSyntax right,
+                BindingDiagnosticBag diagnostics,
+                LookupResult lookupResult,
+                LookupOptions options,
+                SeparatedSyntaxList<TypeSyntax> typeArgumentsSyntax,
+                ImmutableArray<TypeWithAnnotations> typeArguments,
+                string rightName,
+                int rightArity)
+            {
+                // If K is zero and E is a namespace and E contains a nested namespace with name I, 
+                // then the result is that namespace.
+
+                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
+                this.LookupMembersWithFallback(lookupResult, ns, rightName, rightArity, ref useSiteInfo, options: options);
+                diagnostics.Add(right, useSiteInfo);
+
+                ArrayBuilder<Symbol> symbols = lookupResult.Symbols;
+
+                if (lookupResult.IsMultiViable)
+                {
+                    bool wasError;
+                    Symbol sym = ResultSymbol(lookupResult, rightName, rightArity, node, diagnostics, false, out wasError, ns, options);
+                    if (wasError)
+                    {
+                        return new BoundBadExpression(node, LookupResultKind.Ambiguous, lookupResult.Symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true);
+                    }
+                    else if (sym.Kind == SymbolKind.Namespace)
+                    {
+                        return new BoundNamespaceExpression(node, (NamespaceSymbol)sym);
+                    }
+                    else
+                    {
+                        Debug.Assert(sym.Kind == SymbolKind.NamedType);
+                        var type = (NamedTypeSymbol)sym;
+
+                        if (!typeArguments.IsDefault)
+                        {
+                            type = ConstructNamedTypeUnlessTypeArgumentOmitted(right, type, typeArgumentsSyntax, typeArguments, diagnostics);
+                        }
+
+                        ReportDiagnosticsIfObsolete(diagnostics, type, node, hasBaseReceiver: false);
+
+                        return new BoundTypeExpression(node, null, type);
+                    }
+                }
+                else if (lookupResult.Kind == LookupResultKind.WrongArity)
+                {
+                    Debug.Assert(symbols.Count > 0);
+                    Debug.Assert(symbols[0].Kind == SymbolKind.NamedType);
+
+                    Error(diagnostics, lookupResult.Error, right);
+
+                    return new BoundTypeExpression(node, null,
+                                new ExtendedErrorTypeSymbol(GetContainingNamespaceOrType(symbols[0]), symbols.ToImmutable(), lookupResult.Kind, lookupResult.Error, rightArity));
+                }
+                else if (lookupResult.Kind == LookupResultKind.Empty)
+                {
+                    Debug.Assert(lookupResult.IsClear, "If there's a legitimate reason for having candidates without a reason, then we should produce something intelligent in such cases.");
+                    Debug.Assert(lookupResult.Error == null);
+                    NotFound(node, rightName, rightArity, rightName, diagnostics, aliasOpt: null, qualifierOpt: ns, options: options);
+
+                    return new BoundBadExpression(node, lookupResult.Kind, symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true);
+                }
+
+                return null;
+            }
+
+            [MethodImpl(MethodImplOptions.NoInlining)]
+            BoundExpression tryBindMemberAccessWithBoundTypeLeft(
+                ExpressionSyntax node,
+                BoundExpression boundLeft,
+                SimpleNameSyntax right,
+                bool invoked,
+                bool indexed,
+                BindingDiagnosticBag diagnostics,
+                TypeSymbol leftType,
+                LookupResult lookupResult,
+                LookupOptions options,
+                SeparatedSyntaxList<TypeSyntax> typeArgumentsSyntax,
+                ImmutableArray<TypeWithAnnotations> typeArguments,
+                string rightName,
+                int rightArity)
+            {
+                Debug.Assert((object)leftType != null);
+                if (leftType.TypeKind == TypeKind.TypeParameter)
+                {
+                    CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
+                    this.LookupMembersWithFallback(lookupResult, leftType, rightName, rightArity, ref useSiteInfo, basesBeingResolved: null, options: options | LookupOptions.MustNotBeInstance | LookupOptions.MustBeAbstract);
+                    diagnostics.Add(right, useSiteInfo);
+                    if (lookupResult.IsMultiViable)
+                    {
+                        CheckFeatureAvailability(boundLeft.Syntax, MessageID.IDS_FeatureStaticAbstractMembersInInterfaces, diagnostics);
+                        return BindMemberOfType(node, right, rightName, rightArity, indexed, boundLeft, typeArgumentsSyntax, typeArguments, lookupResult, BoundMethodGroupFlags.None, diagnostics: diagnostics);
+                    }
+                    else if (lookupResult.IsClear)
+                    {
+                        Error(diagnostics, ErrorCode.ERR_BadSKunknown, boundLeft.Syntax, leftType, MessageID.IDS_SK_TYVAR.Localize());
+                        return BadExpression(node, LookupResultKind.NotAValue, boundLeft);
+                    }
+                }
+                else if (this.EnclosingNameofArgument == node)
+                {
+                    // Support selecting an extension method from a type name in nameof(.)
+                    return BindInstanceMemberAccess(node, right, boundLeft, rightName, rightArity, typeArgumentsSyntax, typeArguments, invoked, indexed, diagnostics);
+                }
+                else
+                {
+                    CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
+                    this.LookupMembersWithFallback(lookupResult, leftType, rightName, rightArity, ref useSiteInfo, basesBeingResolved: null, options: options);
+                    diagnostics.Add(right, useSiteInfo);
+                    if (lookupResult.IsMultiViable)
+                    {
+                        return BindMemberOfType(node, right, rightName, rightArity, indexed, boundLeft, typeArgumentsSyntax, typeArguments, lookupResult, BoundMethodGroupFlags.None, diagnostics: diagnostics);
+                    }
+                }
+
+                return null;
+            }
         }
 
         private void WarnOnAccessOfOffDefault(SyntaxNode node, BoundExpression boundLeft, BindingDiagnosticBag diagnostics)
@@ -6943,7 +7003,7 @@ protected BoundExpression BindFieldAccess(
 
             if (!IsBadBaseAccess(node, receiver, fieldSymbol, diagnostics))
             {
-                CheckRuntimeSupportForSymbolAccess(node, receiver, fieldSymbol, diagnostics);
+                CheckReceiverAndRuntimeSupportForSymbolAccess(node, receiver, fieldSymbol, diagnostics);
             }
 
             TypeSymbol fieldType = fieldSymbol.GetFieldType(this.FieldsBeingBound).Type;
@@ -7019,25 +7079,50 @@ private BoundExpression BindPropertyAccess(
             return new BoundPropertyAccess(node, receiver, propertySymbol, lookupResult, propertySymbol.Type, hasErrors: (hasErrors || hasError));
         }
 
-        private void CheckRuntimeSupportForSymbolAccess(SyntaxNode node, BoundExpression receiverOpt, Symbol symbol, BindingDiagnosticBag diagnostics)
+        private void CheckReceiverAndRuntimeSupportForSymbolAccess(SyntaxNode node, BoundExpression receiverOpt, Symbol symbol, BindingDiagnosticBag diagnostics)
         {
-            if (symbol.ContainingType?.IsInterface == true && !Compilation.Assembly.RuntimeSupportsDefaultInterfaceImplementation && Compilation.SourceModule != symbol.ContainingModule)
+            if (symbol.ContainingType?.IsInterface == true)
             {
-                if (!symbol.IsStatic && !(symbol is TypeSymbol) &&
-                    !symbol.IsImplementableInterfaceMember())
+                if (symbol.IsStatic && symbol.IsAbstract)
                 {
-                    Error(diagnostics, ErrorCode.ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation, node);
+                    Debug.Assert(symbol is not TypeSymbol);
+
+                    if (receiverOpt is BoundQueryClause { Value: var value })
+                    {
+                        receiverOpt = value;
+                    }
+
+                    if (receiverOpt is not BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } })
+                    {
+                        Error(diagnostics, ErrorCode.ERR_BadAbstractStaticMemberAccess, node);
+                        return;
+                    }
+
+                    if (!Compilation.Assembly.RuntimeSupportsStaticAbstractMembersInInterfaces && Compilation.SourceModule != symbol.ContainingModule)
+                    {
+                        Error(diagnostics, ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, node);
+                        return;
+                    }
                 }
-                else
+
+                if (!Compilation.Assembly.RuntimeSupportsDefaultInterfaceImplementation && Compilation.SourceModule != symbol.ContainingModule)
                 {
-                    switch (symbol.DeclaredAccessibility)
+                    if (!symbol.IsStatic && !(symbol is TypeSymbol) &&
+                        !symbol.IsImplementableInterfaceMember())
+                    {
+                        Error(diagnostics, ErrorCode.ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation, node);
+                    }
+                    else
                     {
-                        case Accessibility.Protected:
-                        case Accessibility.ProtectedOrInternal:
-                        case Accessibility.ProtectedAndInternal:
+                        switch (symbol.DeclaredAccessibility)
+                        {
+                            case Accessibility.Protected:
+                            case Accessibility.ProtectedOrInternal:
+                            case Accessibility.ProtectedAndInternal:
 
-                            Error(diagnostics, ErrorCode.ERR_RuntimeDoesNotSupportProtectedAccessForInterfaceMember, node);
-                            break;
+                                Error(diagnostics, ErrorCode.ERR_RuntimeDoesNotSupportProtectedAccessForInterfaceMember, node);
+                                break;
+                        }
                     }
                 }
             }
@@ -8470,6 +8555,8 @@ static bool isCandidateUnique(ref MethodSymbol? method, MethodSymbol candidate)
             ImmutableArray<TypeWithAnnotations> parameterTypes,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
+            Debug.Assert(returnTypeOpt.Type?.IsVoidType() != true); // expecting !returnTypeOpt.HasType rather than System.Void
+
             if (returnRefKind == RefKind.None &&
                 (parameterRefKinds.IsDefault || parameterRefKinds.All(refKind => refKind == RefKind.None)))
             {
@@ -8610,15 +8697,15 @@ private BoundConditionalAccess BindConditionalAccessExpression(ConditionalAccess
                             break;
 
                         case SyntaxKind.SimpleLambdaExpression:
-                            resultIsUsed = (((SimpleLambdaExpressionSyntax)parent).Body != node) || ContainingMethodOrLambdaRequiresValue();
+                            resultIsUsed = (((SimpleLambdaExpressionSyntax)parent).Body != node) || MethodOrLambdaRequiresValue(ContainingMemberOrLambda, Compilation);
                             break;
 
                         case SyntaxKind.ParenthesizedLambdaExpression:
-                            resultIsUsed = (((ParenthesizedLambdaExpressionSyntax)parent).Body != node) || ContainingMethodOrLambdaRequiresValue();
+                            resultIsUsed = (((ParenthesizedLambdaExpressionSyntax)parent).Body != node) || MethodOrLambdaRequiresValue(ContainingMemberOrLambda, Compilation);
                             break;
 
                         case SyntaxKind.ArrowExpressionClause:
-                            resultIsUsed = (((ArrowExpressionClauseSyntax)parent).Expression != node) || ContainingMethodOrLambdaRequiresValue();
+                            resultIsUsed = (((ArrowExpressionClauseSyntax)parent).Expression != node) || MethodOrLambdaRequiresValue(ContainingMemberOrLambda, Compilation);
                             break;
 
                         case SyntaxKind.ForStatement:
@@ -8648,13 +8735,11 @@ private BoundConditionalAccess BindConditionalAccessExpression(ConditionalAccess
             return new BoundConditionalAccess(node, receiver, access, accessType);
         }
 
-        private bool ContainingMethodOrLambdaRequiresValue()
+        internal static bool MethodOrLambdaRequiresValue(Symbol symbol, CSharpCompilation compilation)
         {
-            var containingMethod = ContainingMemberOrLambda as MethodSymbol;
-            return
-                (object)containingMethod == null ||
-                    !containingMethod.ReturnsVoid &&
-                    !containingMethod.IsAsyncReturningTask(this.Compilation);
+            return symbol is MethodSymbol method &&
+                !method.ReturnsVoid &&
+                !method.IsAsyncEffectivelyReturningTask(compilation);
         }
 
         private BoundConditionalAccess GenerateBadConditionalAccessNodeError(ConditionalAccessExpressionSyntax node, BoundExpression receiver, BoundExpression access, BindingDiagnosticBag diagnostics)
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs
index 7eb03207090c9..ee4dad5e40adf 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs
@@ -38,10 +38,12 @@ private UnboundLambda AnalyzeAnonymousFunction(
             Debug.Assert(syntax != null);
             Debug.Assert(syntax.IsAnonymousFunction());
 
-            var names = default(ImmutableArray<string>);
-            var refKinds = default(ImmutableArray<RefKind>);
-            var types = default(ImmutableArray<TypeWithAnnotations>);
-            var attributes = default(ImmutableArray<SyntaxList<AttributeListSyntax>>);
+            ImmutableArray<string> names = default;
+            ImmutableArray<RefKind> refKinds = default;
+            ImmutableArray<TypeWithAnnotations> types = default;
+            RefKind returnRefKind = RefKind.None;
+            TypeWithAnnotations returnType = default;
+            ImmutableArray<SyntaxList<AttributeListSyntax>> parameterAttributes = default;
 
             var namesBuilder = ArrayBuilder<string>.GetInstance();
             ImmutableArray<bool> discardsOpt = default;
@@ -67,6 +69,10 @@ private UnboundLambda AnalyzeAnonymousFunction(
                     // (x, y) => ...
                     hasSignature = true;
                     var paren = (ParenthesizedLambdaExpressionSyntax)syntax;
+                    if (paren.ReturnType is { } returnTypeSyntax)
+                    {
+                        (returnRefKind, returnType) = BindExplicitLambdaReturnType(returnTypeSyntax, diagnostics);
+                    }
                     parameterSyntaxList = paren.ParameterList.Parameters;
                     CheckParenthesizedLambdaParameters(parameterSyntaxList.Value, diagnostics);
                     break;
@@ -187,7 +193,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
                 if (attributesBuilder.Any(a => a.Count > 0))
                 {
-                    attributes = attributesBuilder.ToImmutable();
+                    parameterAttributes = attributesBuilder.ToImmutable();
                 }
 
                 typesBuilder.Free();
@@ -202,7 +208,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
             namesBuilder.Free();
 
-            return new UnboundLambda(syntax, this, diagnostics.AccumulatesDependencies, attributes, refKinds, types, names, discardsOpt, isAsync, isStatic);
+            return new UnboundLambda(syntax, this, diagnostics.AccumulatesDependencies, returnRefKind, returnType, parameterAttributes, refKinds, types, names, discardsOpt, isAsync, isStatic);
 
             static ImmutableArray<bool> computeDiscards(SeparatedSyntaxList<ParameterSyntax> parameters, int underscoresCount)
             {
@@ -237,6 +243,26 @@ static void checkAttributes(AnonymousFunctionExpressionSyntax syntax, SyntaxList
             }
         }
 
+        private (RefKind, TypeWithAnnotations) BindExplicitLambdaReturnType(TypeSyntax syntax, BindingDiagnosticBag diagnostics)
+        {
+            MessageID.IDS_FeatureLambdaReturnType.CheckFeatureAvailability(diagnostics, syntax);
+
+            syntax = syntax.SkipRef(out RefKind refKind);
+            var returnType = BindType(syntax, diagnostics);
+            var type = returnType.Type;
+
+            if (returnType.IsStatic)
+            {
+                diagnostics.Add(ErrorFacts.GetStaticClassReturnCode(useWarning: false), syntax.Location, type);
+            }
+            else if (returnType.IsRestrictedType(ignoreSpanLikeTypes: true))
+            {
+                diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, syntax.Location, type);
+            }
+
+            return (refKind, returnType);
+        }
+
         private static void CheckParenthesizedLambdaParameters(
             SeparatedSyntaxList<ParameterSyntax> parameterSyntaxList, BindingDiagnosticBag diagnostics)
         {
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs
index 944d773b9c6b1..b3c7b8b577973 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs
@@ -1323,6 +1323,7 @@ internal static ImmutableArray<Symbol> GetCandidateMembers(NamespaceOrTypeSymbol
         /// </remarks>
         internal SingleLookupResult CheckViability(Symbol symbol, int arity, LookupOptions options, TypeSymbol accessThroughType, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, ConsList<TypeSymbol> basesBeingResolved = null)
         {
+            Debug.Assert((options & LookupOptions.MustBeAbstract) == 0 || (options & LookupOptions.MustNotBeInstance) != 0);
             bool inaccessibleViaQualifier;
             DiagnosticInfo diagInfo;
 
@@ -1338,6 +1339,11 @@ internal SingleLookupResult CheckViability(Symbol symbol, int arity, LookupOptio
             {
                 return LookupResult.Empty();
             }
+            else if ((options & (LookupOptions.MustNotBeInstance | LookupOptions.MustBeAbstract)) == (LookupOptions.MustNotBeInstance | LookupOptions.MustBeAbstract) &&
+                (unwrappedSymbol is not TypeSymbol && IsInstance(unwrappedSymbol) || !unwrappedSymbol.IsAbstract))
+            {
+                return LookupResult.Empty();
+            }
             else if (WrongArity(symbol, arity, diagnose, options, out diagInfo))
             {
                 return LookupResult.WrongArity(symbol, diagInfo);
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
index f1cd8b3a45564..0e4bcb0bbecad 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
@@ -169,6 +169,7 @@ private BoundExpression BindCompoundAssignment(AssignmentExpressionSyntax node,
             BinaryOperatorSignature bestSignature = best.Signature;
 
             CheckNativeIntegerFeatureAvailability(bestSignature.Kind, node, diagnostics);
+            CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, bestSignature.Method, bestSignature.ConstrainedToTypeOpt, diagnostics);
 
             if (CheckOverflowAtRuntime)
             {
@@ -177,7 +178,8 @@ private BoundExpression BindCompoundAssignment(AssignmentExpressionSyntax node,
                     bestSignature.LeftType,
                     bestSignature.RightType,
                     bestSignature.ReturnType,
-                    bestSignature.Method);
+                    bestSignature.Method,
+                    bestSignature.ConstrainedToTypeOpt);
             }
 
             BoundExpression rightConverted = CreateConversion(right, best.RightConversion, bestSignature.RightType, diagnostics);
@@ -195,6 +197,7 @@ private BoundExpression BindCompoundAssignment(AssignmentExpressionSyntax node,
             else
             {
                 ReportDiagnosticsIfObsolete(diagnostics, finalConversion, node, hasBaseReceiver: false);
+                CheckConstraintLanguageVersionAndRuntimeSupportForConversion(node, finalConversion, diagnostics);
             }
 
             if (finalConversion.IsExplicit &&
@@ -223,6 +226,7 @@ private BoundExpression BindCompoundAssignment(AssignmentExpressionSyntax node,
 
             Conversion leftConversion = best.LeftConversion;
             ReportDiagnosticsIfObsolete(diagnostics, leftConversion, node, hasBaseReceiver: false);
+            CheckConstraintLanguageVersionAndRuntimeSupportForConversion(node, leftConversion, diagnostics);
 
             return new BoundCompoundAssignmentOperator(node, bestSignature, left, rightConverted,
                 leftConversion, finalConversion, resultKind, originalUserDefinedOperators, leftType, hasError);
@@ -292,7 +296,7 @@ private BoundExpression BindEventAssignment(AssignmentExpressionSyntax node, Bou
                 }
                 else
                 {
-                    CheckRuntimeSupportForSymbolAccess(node, receiverOpt, method, diagnostics);
+                    CheckReceiverAndRuntimeSupportForSymbolAccess(node, receiverOpt, method, diagnostics);
                 }
 
                 if (eventSymbol.IsWindowsRuntimeEvent)
@@ -382,6 +386,12 @@ private BoundExpression BindDynamicBinaryOperator(
 
                     hasError = true;
                 }
+                else
+                {
+                    Debug.Assert(left.Type is not TypeParameterSymbol);
+                    CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, userDefinedOperator, constrainedToTypeOpt: null, diagnostics);
+                }
+
                 diagnostics.Add(node, useSiteInfo);
             }
 
@@ -392,6 +402,7 @@ private BoundExpression BindDynamicBinaryOperator(
                 right: BindToNaturalType(right, diagnostics),
                 constantValueOpt: ConstantValue.NotAvailable,
                 methodOpt: userDefinedOperator,
+                constrainedToTypeOpt: null,
                 resultKind: LookupResultKind.Viable,
                 type: Compilation.DynamicType,
                 hasErrors: hasError);
@@ -491,7 +502,7 @@ private BoundExpression BindSimpleBinaryOperator(BinaryExpressionSyntax node, Bi
                 // NOTE: no user-defined conversion candidates
                 left = BindToTypeForErrorRecovery(left);
                 right = BindToTypeForErrorRecovery(right);
-                return new BoundBinaryOperator(node, kind, ConstantValue.NotAvailable, null, LookupResultKind.Empty, left, right, GetBinaryOperatorErrorType(kind, diagnostics, node), true);
+                return new BoundBinaryOperator(node, kind, ConstantValue.NotAvailable, methodOpt: null, constrainedToTypeOpt: null, LookupResultKind.Empty, left, right, GetBinaryOperatorErrorType(kind, diagnostics, node), true);
             }
 
             TypeSymbol leftType = left.Type;
@@ -587,6 +598,7 @@ private BoundExpression BindSimpleBinaryOperator(BinaryExpressionSyntax node, Bi
             }
 
             CheckNativeIntegerFeatureAvailability(resultOperatorKind, node, diagnostics);
+            CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, signature.Method, signature.ConstrainedToTypeOpt, diagnostics);
 
             TypeSymbol resultType = signature.ReturnType;
             BoundExpression resultLeft = left;
@@ -619,6 +631,7 @@ private BoundExpression BindSimpleBinaryOperator(BinaryExpressionSyntax node, Bi
                 resultRight,
                 resultConstant,
                 signature.Method,
+                signature.ConstrainedToTypeOpt,
                 resultKind,
                 originalUserDefinedOperators,
                 resultType,
@@ -803,7 +816,7 @@ private BoundExpression BindConditionalLogicalOperator(BinaryExpressionSyntax no
                 var constantValue = FoldBinaryOperator(node, kind | BinaryOperatorKind.Bool, left, right, SpecialType.System_Boolean, diagnostics);
 
                 // NOTE: no candidate user-defined operators.
-                return new BoundBinaryOperator(node, kind | BinaryOperatorKind.Bool, constantValue, methodOpt: null,
+                return new BoundBinaryOperator(node, kind | BinaryOperatorKind.Bool, constantValue, methodOpt: null, constrainedToTypeOpt: null,
                     resultKind: LookupResultKind.Viable, left, right, type: left.Type, hasErrors: constantValue != null && constantValue.IsBad);
             }
 
@@ -813,7 +826,7 @@ private BoundExpression BindConditionalLogicalOperator(BinaryExpressionSyntax no
             if (left.HasAnyErrors || right.HasAnyErrors)
             {
                 // NOTE: no candidate user-defined operators.
-                return new BoundBinaryOperator(node, kind, ConstantValue.NotAvailable, methodOpt: null,
+                return new BoundBinaryOperator(node, kind, ConstantValue.NotAvailable, methodOpt: null, constrainedToTypeOpt: null,
                     resultKind: LookupResultKind.Empty, left, right, type: GetBinaryOperatorErrorType(kind, diagnostics, node), hasErrors: true);
             }
 
@@ -871,6 +884,9 @@ private BoundExpression BindConditionalLogicalOperator(BinaryExpressionSyntax no
                     {
                         Debug.Assert(trueOperator != null && falseOperator != null);
 
+                        _ = CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, signature.Method, signature.ConstrainedToTypeOpt, diagnostics) &&
+                            CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, kind == BinaryOperatorKind.LogicalAnd ? falseOperator : trueOperator, signature.ConstrainedToTypeOpt, diagnostics);
+
                         return new BoundUserDefinedConditionalLogicalOperator(
                             node,
                             resultKind,
@@ -879,6 +895,7 @@ private BoundExpression BindConditionalLogicalOperator(BinaryExpressionSyntax no
                             signature.Method,
                             trueOperator,
                             falseOperator,
+                            signature.ConstrainedToTypeOpt,
                             lookupResult,
                             originalUserDefinedOperators,
                             signature.ReturnType);
@@ -886,6 +903,7 @@ private BoundExpression BindConditionalLogicalOperator(BinaryExpressionSyntax no
                     else
                     {
                         Debug.Assert(bothBool);
+                        Debug.Assert(!(signature.Method?.ContainingType?.IsInterface ?? false));
 
                         return new BoundBinaryOperator(
                             node,
@@ -894,6 +912,7 @@ private BoundExpression BindConditionalLogicalOperator(BinaryExpressionSyntax no
                             resultRight,
                             ConstantValue.NotAvailable,
                             signature.Method,
+                            signature.ConstrainedToTypeOpt,
                             lookupResult,
                             originalUserDefinedOperators,
                             signature.ReturnType);
@@ -902,7 +921,7 @@ private BoundExpression BindConditionalLogicalOperator(BinaryExpressionSyntax no
             }
 
             // We've already reported the error.
-            return new BoundBinaryOperator(node, kind, left, right, ConstantValue.NotAvailable, null, lookupResult, originalUserDefinedOperators, CreateErrorType(), true);
+            return new BoundBinaryOperator(node, kind, left, right, ConstantValue.NotAvailable, methodOpt: null, constrainedToTypeOpt: null, lookupResult, originalUserDefinedOperators, CreateErrorType(), true);
         }
 
         private bool IsValidDynamicCondition(BoundExpression left, bool isNegative, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out MethodSymbol userDefinedOperator)
@@ -994,8 +1013,10 @@ private bool IsValidUserDefinedConditionalLogicalOperator(
             // As mentioned above, we relax this restriction. The types must all be the same.
 
             bool typesAreSame = TypeSymbol.Equals(signature.LeftType, signature.RightType, TypeCompareKind.ConsiderEverything2) && TypeSymbol.Equals(signature.LeftType, signature.ReturnType, TypeCompareKind.ConsiderEverything2);
-            bool typeMatchesContainer = TypeSymbol.Equals(signature.ReturnType, t, TypeCompareKind.ConsiderEverything2) ||
-                signature.ReturnType.IsNullableType() && TypeSymbol.Equals(signature.ReturnType.GetNullableUnderlyingType(), t, TypeCompareKind.ConsiderEverything2);
+            MethodSymbol definition;
+            bool typeMatchesContainer = TypeSymbol.Equals(signature.ReturnType.StrippedType(), t, TypeCompareKind.ConsiderEverything2) ||
+                                        (t.IsInterface && signature.Method.IsAbstract &&
+                                         SourceUserDefinedOperatorSymbol.IsSelfConstrainedTypeParameter((definition = signature.Method.OriginalDefinition).ReturnType.StrippedType(), definition.ContainingType));
 
             if (!typesAreSame || !typeMatchesContainer)
             {
@@ -2087,7 +2108,8 @@ private BoundExpression BindIncrementOperator(CSharpSyntaxNode node, ExpressionS
                     node,
                     kind,
                     operand,
-                    null,
+                    methodOpt: null,
+                    constrainedToTypeOpt: null,
                     Conversion.NoConversion,
                     Conversion.NoConversion,
                     LookupResultKind.Empty,
@@ -2106,6 +2128,7 @@ private BoundExpression BindIncrementOperator(CSharpSyntaxNode node, ExpressionS
                     kind.WithType(UnaryOperatorKind.Dynamic).WithOverflowChecksIfApplicable(CheckOverflowAtRuntime),
                     operand,
                     methodOpt: null,
+                    constrainedToTypeOpt: null,
                     operandConversion: Conversion.NoConversion,
                     resultConversion: Conversion.NoConversion,
                     resultKind: LookupResultKind.Viable,
@@ -2124,7 +2147,8 @@ private BoundExpression BindIncrementOperator(CSharpSyntaxNode node, ExpressionS
                     node,
                     kind,
                     operand,
-                    null,
+                    methodOpt: null,
+                    constrainedToTypeOpt: null,
                     Conversion.NoConversion,
                     Conversion.NoConversion,
                     resultKind,
@@ -2136,6 +2160,7 @@ private BoundExpression BindIncrementOperator(CSharpSyntaxNode node, ExpressionS
             var signature = best.Signature;
 
             CheckNativeIntegerFeatureAvailability(signature.Kind, node, diagnostics);
+            CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, signature.Method, signature.ConstrainedToTypeOpt, diagnostics);
 
             CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
             var resultConversion = Conversions.ClassifyConversionFromType(signature.ReturnType, operandType, ref useSiteInfo);
@@ -2150,6 +2175,7 @@ private BoundExpression BindIncrementOperator(CSharpSyntaxNode node, ExpressionS
             else
             {
                 ReportDiagnosticsIfObsolete(diagnostics, resultConversion, node, hasBaseReceiver: false);
+                CheckConstraintLanguageVersionAndRuntimeSupportForConversion(node, resultConversion, diagnostics);
             }
 
             if (!hasErrors && operandType.IsVoidPointer())
@@ -2161,12 +2187,14 @@ private BoundExpression BindIncrementOperator(CSharpSyntaxNode node, ExpressionS
             Conversion operandConversion = best.Conversion;
 
             ReportDiagnosticsIfObsolete(diagnostics, operandConversion, node, hasBaseReceiver: false);
+            CheckConstraintLanguageVersionAndRuntimeSupportForConversion(node, operandConversion, diagnostics);
 
             return new BoundIncrementOperator(
                 node,
                 signature.Kind.WithOverflowChecksIfApplicable(CheckOverflowAtRuntime),
                 operand,
                 signature.Method,
+                signature.ConstrainedToTypeOpt,
                 operandConversion,
                 resultConversion,
                 resultKind,
@@ -2175,6 +2203,45 @@ private BoundExpression BindIncrementOperator(CSharpSyntaxNode node, ExpressionS
                 hasErrors);
         }
 
+#nullable enable
+        /// <summary>
+        /// Returns false if reported an error, true otherwise.
+        /// </summary>
+        private bool CheckConstraintLanguageVersionAndRuntimeSupportForOperator(SyntaxNode node, MethodSymbol? methodOpt, TypeSymbol? constrainedToTypeOpt, BindingDiagnosticBag diagnostics)
+        {
+            bool result = true;
+
+            if (methodOpt?.ContainingType?.IsInterface == true && methodOpt.IsStatic)
+            {
+                if (methodOpt.IsAbstract)
+                {
+                    if (constrainedToTypeOpt is not TypeParameterSymbol)
+                    {
+                        Error(diagnostics, ErrorCode.ERR_BadAbstractStaticMemberAccess, node);
+                        return false;
+                    }
+
+                    if (Compilation.SourceModule != methodOpt.ContainingModule)
+                    {
+                        result = CheckFeatureAvailability(node, MessageID.IDS_FeatureStaticAbstractMembersInInterfaces, diagnostics);
+
+                        if (!Compilation.Assembly.RuntimeSupportsStaticAbstractMembersInInterfaces)
+                        {
+                            Error(diagnostics, ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, node);
+                            return false;
+                        }
+                    }
+                }
+                else if (methodOpt.Name is WellKnownMemberNames.EqualityOperatorName or WellKnownMemberNames.InequalityOperatorName)
+                {
+                    result = CheckFeatureAvailability(node, MessageID.IDS_FeatureStaticAbstractMembersInInterfaces, diagnostics);
+                }
+            }
+
+            return result;
+        }
+#nullable disable
+
         private BoundExpression BindSuppressNullableWarningExpression(PostfixUnaryExpressionSyntax node, BindingDiagnosticBag diagnostics)
         {
             var expr = BindExpression(node.Operand, diagnostics);
@@ -2456,6 +2523,7 @@ private BoundExpression BindUnaryOperatorCore(CSharpSyntaxNode node, string oper
                 // Note: no candidate user-defined operators.
                 return new BoundUnaryOperator(node, kind, operand, ConstantValue.NotAvailable,
                     methodOpt: null,
+                    constrainedToTypeOpt: null,
                     resultKind: LookupResultKind.Empty,
                     type: CreateErrorType(),
                     hasErrors: true);
@@ -2476,6 +2544,7 @@ private BoundExpression BindUnaryOperatorCore(CSharpSyntaxNode node, string oper
                     operand: operand,
                     constantValueOpt: ConstantValue.NotAvailable,
                     methodOpt: null,
+                    constrainedToTypeOpt: null,
                     resultKind: LookupResultKind.Viable,
                     type: operand.Type!);
             }
@@ -2491,7 +2560,8 @@ private BoundExpression BindUnaryOperatorCore(CSharpSyntaxNode node, string oper
                     kind,
                     operand,
                     ConstantValue.NotAvailable,
-                    null,
+                    methodOpt: null,
+                    constrainedToTypeOpt: null,
                     resultKind,
                     originalUserDefinedOperators,
                     CreateErrorType(),
@@ -2503,17 +2573,18 @@ private BoundExpression BindUnaryOperatorCore(CSharpSyntaxNode node, string oper
             var resultOperand = CreateConversion(operand.Syntax, operand, best.Conversion, isCast: false, conversionGroupOpt: null, signature.OperandType, diagnostics);
             var resultType = signature.ReturnType;
             UnaryOperatorKind resultOperatorKind = signature.Kind;
-            var resultMethod = signature.Method;
             var resultConstant = FoldUnaryOperator(node, resultOperatorKind, resultOperand, resultType.SpecialType, diagnostics);
 
             CheckNativeIntegerFeatureAvailability(resultOperatorKind, node, diagnostics);
+            CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, signature.Method, signature.ConstrainedToTypeOpt, diagnostics);
 
             return new BoundUnaryOperator(
                 node,
                 resultOperatorKind.WithOverflowChecksIfApplicable(CheckOverflowAtRuntime),
                 resultOperand,
                 resultConstant,
-                resultMethod,
+                signature.Method,
+                signature.ConstrainedToTypeOpt,
                 resultKind,
                 resultType);
         }
@@ -3777,6 +3848,7 @@ private BoundExpression BindNullCoalescingOperator(BinaryExpressionSyntax node,
                     else
                     {
                         ReportDiagnosticsIfObsolete(diagnostics, leftConversion, node, hasBaseReceiver: false);
+                        CheckConstraintLanguageVersionAndRuntimeSupportForConversion(node, leftConversion, diagnostics);
                     }
 
                     diagnostics.Add(node, useSiteInfo);
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
index dcf551b0e78c0..38c543310628c 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
@@ -780,6 +780,7 @@ protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression r
             {
                 if (ultimateReceiver.Type.TypeKind == TypeKind.TypeParameter)
                 {
+                    // https://github.com/dotnet/roslyn/issues/53796: Do we really want to enable usage of static abstract members here?
                     Error(diagnostics, ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax, ultimateReceiver.Type, MessageID.IDS_SK_TYVAR.Localize());
                 }
             }
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
index 233fcb3033edf..71e10dcfc1e58 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
@@ -623,7 +623,7 @@ BoundBlock runAnalysis(BoundBlock block, BindingDiagnosticBag blockDiagnostics)
 
         private bool ImplicitReturnIsOkay(MethodSymbol method)
         {
-            return method.ReturnsVoid || method.IsIterator || method.IsAsyncReturningTask(this.Compilation);
+            return method.ReturnsVoid || method.IsIterator || method.IsAsyncEffectivelyReturningTask(this.Compilation);
         }
 
         public BoundStatement BindExpressionStatement(ExpressionStatementSyntax node, BindingDiagnosticBag diagnostics)
@@ -1809,6 +1809,7 @@ internal BoundExpression GenerateConversionForAssignment(TypeSymbol targetType,
             return CreateConversion(expression.Syntax, expression, conversion, isCast: false, conversionGroupOpt: null, targetType, diagnostics);
         }
 
+#nullable enable
         internal void GenerateAnonymousFunctionConversionError(BindingDiagnosticBag diagnostics, SyntaxNode syntax,
             UnboundLambda anonymousFunction, TypeSymbol targetType)
         {
@@ -1868,9 +1869,13 @@ internal void GenerateAnonymousFunctionConversionError(BindingDiagnosticBag diag
                 return;
             }
 
-            // At this point we know that we have either a delegate type or an expression type for the target.
+            if (reason == LambdaConversionResult.MismatchedReturnType)
+            {
+                Error(diagnostics, ErrorCode.ERR_CantConvAnonMethReturnType, syntax, id, targetType);
+                return;
+            }
 
-            var delegateType = targetType.GetDelegateType();
+            // At this point we know that we have either a delegate type or an expression type for the target.
 
             // The target type is a valid delegate or expression tree type. Is there something wrong with the
             // parameter list?
@@ -1896,6 +1901,9 @@ internal void GenerateAnonymousFunctionConversionError(BindingDiagnosticBag diag
                 return;
             }
 
+            var delegateType = targetType.GetDelegateType();
+            Debug.Assert(delegateType is not null);
+
             // There is a parameter list. Does it have the right number of elements?
 
             if (reason == LambdaConversionResult.BadParameterCount)
@@ -2013,6 +2021,7 @@ internal void GenerateAnonymousFunctionConversionError(BindingDiagnosticBag diag
             Debug.Assert(false, "Missing case in lambda conversion error reporting");
             diagnostics.Add(ErrorCode.ERR_InternalError, syntax.Location);
         }
+#nullable disable
 
         protected static void GenerateImplicitConversionError(BindingDiagnosticBag diagnostics, CSharpCompilation compilation, SyntaxNode syntax,
             Conversion conversion, TypeSymbol sourceType, TypeSymbol targetType, ConstantValue sourceConstantValueOpt = null)
@@ -2375,7 +2384,8 @@ internal BoundExpression BindBooleanExpression(ExpressionSyntax node, BindingDia
                     UnaryOperatorKind.DynamicTrue,
                     BindToNaturalType(expr, diagnostics),
                     ConstantValue.NotAvailable,
-                    null,
+                    methodOpt: null,
+                    constrainedToTypeOpt: null,
                     LookupResultKind.Viable,
                     boolean)
                 {
@@ -2441,10 +2451,12 @@ internal BoundExpression BindBooleanExpression(ExpressionSyntax node, BindingDia
                 destination: best.Signature.OperandType,
                 diagnostics: diagnostics);
 
+            CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, signature.Method, signature.ConstrainedToTypeOpt, diagnostics);
+
             // Consider op_true to be compiler-generated so that it doesn't appear in the semantic model.
             // UNDONE: If we decide to expose the operator in the semantic model, we'll have to remove the
             // WasCompilerGenerated flag (and possibly suppress the symbol in specific APIs).
-            return new BoundUnaryOperator(node, signature.Kind, resultOperand, ConstantValue.NotAvailable, signature.Method, resultKind, originalUserDefinedOperators, signature.ReturnType)
+            return new BoundUnaryOperator(node, signature.Kind, resultOperand, ConstantValue.NotAvailable, signature.Method, signature.ConstrainedToTypeOpt, resultKind, originalUserDefinedOperators, signature.ReturnType)
             {
                 WasCompilerGenerated = true
             };
@@ -2644,16 +2656,16 @@ protected bool IsInAsyncMethod()
             return IsInAsyncMethod(this.ContainingMemberOrLambda as MethodSymbol);
         }
 
-        protected bool IsTaskReturningAsyncMethod()
+        protected bool IsEffectivelyTaskReturningAsyncMethod()
         {
             var symbol = this.ContainingMemberOrLambda;
-            return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncReturningTask(this.Compilation);
+            return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningTask(this.Compilation);
         }
 
-        protected bool IsGenericTaskReturningAsyncMethod()
+        protected bool IsEffectivelyGenericTaskReturningAsyncMethod()
         {
             var symbol = this.ContainingMemberOrLambda;
-            return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncReturningGenericTask(this.Compilation);
+            return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningGenericTask(this.Compilation);
         }
 
         protected bool IsIAsyncEnumerableOrIAsyncEnumeratorReturningAsyncMethod()
@@ -2756,7 +2768,7 @@ private BoundStatement BindReturn(ReturnStatementSyntax syntax, BindingDiagnosti
             // on a lambda expression of unknown return type.
             if ((object)retType != null)
             {
-                if (retType.IsVoidType() || IsTaskReturningAsyncMethod())
+                if (retType.IsVoidType() || IsEffectivelyTaskReturningAsyncMethod())
                 {
                     if (arg != null)
                     {
@@ -2796,7 +2808,7 @@ private BoundStatement BindReturn(ReturnStatementSyntax syntax, BindingDiagnosti
                     if (arg == null)
                     {
                         // Error case: non-void-returning or Task<T>-returning method or lambda but just have "return;"
-                        var requiredType = IsGenericTaskReturningAsyncMethod()
+                        var requiredType = IsEffectivelyGenericTaskReturningAsyncMethod()
                             ? retType.GetMemberTypeArgumentsNoUseSiteDiagnostics().Single()
                             : retType;
 
@@ -2839,7 +2851,7 @@ internal BoundExpression CreateReturnConversion(
             {
                 Debug.Assert(returnRefKind == RefKind.None);
 
-                if (!IsGenericTaskReturningAsyncMethod())
+                if (!IsEffectivelyGenericTaskReturningAsyncMethod())
                 {
                     conversion = Conversion.NoConversion;
                     badAsyncReturnAlreadyReported = true;
@@ -2876,7 +2888,8 @@ internal BoundExpression CreateReturnConversion(
                     if (!badAsyncReturnAlreadyReported)
                     {
                         RefKind unusedRefKind;
-                        if (IsGenericTaskReturningAsyncMethod() && TypeSymbol.Equals(argument.Type, this.GetCurrentReturnType(out unusedRefKind), TypeCompareKind.ConsiderEverything2))
+                        if (IsEffectivelyGenericTaskReturningAsyncMethod()
+                            && TypeSymbol.Equals(argument.Type, this.GetCurrentReturnType(out unusedRefKind), TypeCompareKind.ConsiderEverything2))
                         {
                             // Since this is an async method, the return expression must be of type '{0}' rather than 'Task<{0}>'
                             Error(diagnostics, ErrorCode.ERR_BadAsyncReturnExpression, argument.Syntax, returnType);
@@ -3165,7 +3178,7 @@ internal BoundBlock CreateBlockFromExpression(CSharpSyntaxNode node, ImmutableAr
                     expression = BindToTypeForErrorRecovery(expression);
                     statement = new BoundReturnStatement(syntax, RefKind.None, expression) { WasCompilerGenerated = true };
                 }
-                else if (returnType.IsVoidType() || IsTaskReturningAsyncMethod())
+                else if (returnType.IsVoidType() || IsEffectivelyTaskReturningAsyncMethod())
                 {
                     // If the return type is void then the expression is required to be a legal
                     // statement expression.
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
index 9438b31a20593..f2c30be9653d3 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
@@ -1700,7 +1700,7 @@ internal Symbol ResultSymbol(
 
             if (symbol.Kind == SymbolKind.NamedType)
             {
-                CheckRuntimeSupportForSymbolAccess(where, receiverOpt: null, symbol, diagnostics);
+                CheckReceiverAndRuntimeSupportForSymbolAccess(where, receiverOpt: null, symbol, diagnostics);
 
                 if (suppressUseSiteDiagnostics && diagnostics.DependenciesBag is object)
                 {
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_TupleOperators.cs b/src/Compilers/CSharp/Portable/Binder/Binder_TupleOperators.cs
index c89dfcf6285ce..27dc594d30ae5 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_TupleOperators.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_TupleOperators.cs
@@ -104,7 +104,9 @@ private TupleBinaryOperatorInfo BindTupleBinaryOperatorInfo(BinaryExpressionSynt
 
                 case BoundBinaryOperator binary:
                     PrepareBoolConversionAndTruthOperator(binary.Type, node, kind, diagnostics, out Conversion conversionIntoBoolOperator, out UnaryOperatorSignature boolOperator);
-                    return new TupleBinaryOperatorInfo.Single(binary.Left.Type, binary.Right.Type, binary.OperatorKind, binary.MethodOpt, conversionIntoBoolOperator, boolOperator);
+                    CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, boolOperator.Method, boolOperator.ConstrainedToTypeOpt, diagnostics);
+
+                    return new TupleBinaryOperatorInfo.Single(binary.Left.Type, binary.Right.Type, binary.OperatorKind, binary.MethodOpt, binary.ConstrainedToTypeOpt, conversionIntoBoolOperator, boolOperator);
 
                 default:
                     throw ExceptionUtilities.UnexpectedValue(comparison);
@@ -130,6 +132,7 @@ private void PrepareBoolConversionAndTruthOperator(TypeSymbol type, BinaryExpres
             if (conversion.IsImplicit)
             {
                 ReportDiagnosticsIfObsolete(diagnostics, conversion, node, hasBaseReceiver: false);
+                CheckConstraintLanguageVersionAndRuntimeSupportForConversion(node, conversion, diagnostics);
                 conversionForBool = conversion;
                 boolOperator = default;
                 return;
@@ -189,7 +192,7 @@ private TupleBinaryOperatorInfo BindTupleDynamicBinaryOperatorSingleInfo(BinaryE
             // We'll want to dynamically invoke operators op_true (/op_false) for equality (/inequality) comparison, but we don't need
             // to prepare either a conversion or a truth operator. Those can just be synthesized during lowering.
             return new TupleBinaryOperatorInfo.Single(dynamicType, dynamicType, elementOperatorKind,
-                methodSymbolOpt: null, conversionForBool: Conversion.Identity, boolOperator: default);
+                methodSymbolOpt: null, constrainedToTypeOpt: null, conversionForBool: Conversion.Identity, boolOperator: default);
         }
 
         private TupleBinaryOperatorInfo.Multiple BindTupleBinaryOperatorNestedInfo(BinaryExpressionSyntax node, BinaryOperatorKind kind,
diff --git a/src/Compilers/CSharp/Portable/Binder/ForEachLoopBinder.cs b/src/Compilers/CSharp/Portable/Binder/ForEachLoopBinder.cs
index b5dad2ee17e58..8b26cf2102d6f 100644
--- a/src/Compilers/CSharp/Portable/Binder/ForEachLoopBinder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/ForEachLoopBinder.cs
@@ -447,6 +447,7 @@ private BoundForEachStatement BindForEachPartsWorker(BindingDiagnosticBag diagno
             else
             {
                 ReportDiagnosticsIfObsolete(diagnostics, elementConversion, _syntax.ForEachKeyword, hasBaseReceiver: false);
+                CheckConstraintLanguageVersionAndRuntimeSupportForConversion(_syntax.ForEachKeyword, elementConversion, diagnostics);
             }
 
             // Spec (§8.8.4):
@@ -493,6 +494,7 @@ private BoundForEachStatement BindForEachPartsWorker(BindingDiagnosticBag diagno
 
             // We're wrapping the collection expression in a (non-synthesized) conversion so that its converted
             // type (i.e. builder.CollectionType) will be available in the binding API.
+            Debug.Assert(!builder.CollectionConversion.IsUserDefined);
             BoundConversion convertedCollectionExpression = new BoundConversion(
                 collectionExpr.Syntax,
                 collectionExpr,
@@ -1259,6 +1261,7 @@ private MethodArgumentInfo FindForEachPatternMethodViaExtension(BoundExpression
                 diagnostics.Add(_syntax, useSiteInfo);
 
                 // Unconditionally convert here, to match what we set the ConvertedExpression to in the main BoundForEachStatement node.
+                Debug.Assert(!collectionConversion.IsUserDefined);
                 collectionExpr = new BoundConversion(
                     collectionExpr.Syntax,
                     collectionExpr,
diff --git a/src/Compilers/CSharp/Portable/Binder/LookupOptions.cs b/src/Compilers/CSharp/Portable/Binder/LookupOptions.cs
index 5d0594144b5de..881d467e40bc0 100644
--- a/src/Compilers/CSharp/Portable/Binder/LookupOptions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/LookupOptions.cs
@@ -100,6 +100,11 @@ internal enum LookupOptions
         /// Do not consider symbols that are method type parameters.
         /// </summary>
         MustNotBeMethodTypeParameter = 1 << 14,
+
+        /// <summary>
+        /// Consider only symbols that are abstract.
+        /// </summary>
+        MustBeAbstract = 1 << 15,
     }
 
     internal static class LookupOptionExtensions
diff --git a/src/Compilers/CSharp/Portable/Binder/MethodArgumentInfo.cs b/src/Compilers/CSharp/Portable/Binder/MethodArgumentInfo.cs
index 5e742d84d72a7..b8a2f76c02e53 100644
--- a/src/Compilers/CSharp/Portable/Binder/MethodArgumentInfo.cs
+++ b/src/Compilers/CSharp/Portable/Binder/MethodArgumentInfo.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
index 19dc172a858b5..082400b2b10c1 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
@@ -384,6 +384,25 @@ internal MethodSymbol? Method
             }
         }
 
+        internal TypeParameterSymbol? ConstrainedToTypeOpt
+        {
+            get
+            {
+                var uncommonData = _uncommonData;
+                if (uncommonData != null && uncommonData._conversionMethod is null)
+                {
+                    var conversionResult = uncommonData._conversionResult;
+                    if (conversionResult.Kind == UserDefinedConversionResultKind.Valid)
+                    {
+                        UserDefinedConversionAnalysis analysis = conversionResult.Results[conversionResult.Best];
+                        return analysis.ConstrainedToTypeOpt;
+                    }
+                }
+
+                return null;
+            }
+        }
+
         internal DeconstructMethodInfo DeconstructionInfo
         {
             get
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
index 16bdf204a88b5..e40db74c57369 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
@@ -1245,7 +1245,6 @@ source.Type is object &&
                 IsNumericType(source.Type) &&
                 IsConstantNumericZero(sourceConstantValue);
         }
-#nullable disable
 
         private static LambdaConversionResult IsAnonymousFunctionCompatibleWithDelegate(UnboundLambda anonymousFunction, TypeSymbol type)
         {
@@ -1265,6 +1264,15 @@ private static LambdaConversionResult IsAnonymousFunctionCompatibleWithDelegate(
                 return LambdaConversionResult.BadTargetType;
             }
 
+            if (anonymousFunction.HasExplicitReturnType(out var refKind, out var returnType))
+            {
+                if (invokeMethod.RefKind != refKind ||
+                    !invokeMethod.ReturnType.Equals(returnType.Type, TypeCompareKind.AllIgnoreOptions))
+                {
+                    return LambdaConversionResult.MismatchedReturnType;
+                }
+            }
+
             var delegateParameters = invokeMethod.Parameters;
 
             // SPEC: If F contains an anonymous-function-signature, then D and F have the same number of parameters.
@@ -1425,6 +1433,7 @@ private static bool HasAnonymousFunctionConversion(BoundExpression source, TypeS
 
             return IsAnonymousFunctionCompatibleWithType((UnboundLambda)source, destination) == LambdaConversionResult.Success;
         }
+#nullable disable
 
         internal Conversion ClassifyImplicitUserDefinedConversionForV6SwitchGoverningType(TypeSymbol sourceType, out TypeSymbol switchGoverningType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/LambdaConversionResult.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/LambdaConversionResult.cs
index c75d6033426cd..5a10903cb935a 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/LambdaConversionResult.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/LambdaConversionResult.cs
@@ -2,12 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
-
 namespace Microsoft.CodeAnalysis.CSharp
 {
     internal enum LambdaConversionResult
@@ -16,6 +10,7 @@ internal enum LambdaConversionResult
         BadTargetType,
         BadParameterCount,
         MissingSignatureWithOutParameter,
+        MismatchedReturnType,
         MismatchedParameterType,
         RefInImplicitlyTypedLambda,
         StaticTypeInImplicitlyTypedLambda,
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedConversionAnalysis.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedConversionAnalysis.cs
index f6d2846eaff3b..56a7e2e00f34c 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedConversionAnalysis.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedConversionAnalysis.cs
@@ -20,6 +20,7 @@ internal sealed class UserDefinedConversionAnalysis
     {
         public readonly TypeSymbol FromType;
         public readonly TypeSymbol ToType;
+        public readonly TypeParameterSymbol ConstrainedToTypeOpt;
         public readonly MethodSymbol Operator;
 
         public readonly Conversion SourceConversion;
@@ -27,6 +28,7 @@ internal sealed class UserDefinedConversionAnalysis
         public readonly UserDefinedConversionAnalysisKind Kind;
 
         public static UserDefinedConversionAnalysis Normal(
+            TypeParameterSymbol constrainedToTypeOpt,
             MethodSymbol op,
             Conversion sourceConversion,
             Conversion targetConversion,
@@ -35,6 +37,7 @@ public static UserDefinedConversionAnalysis Normal(
         {
             return new UserDefinedConversionAnalysis(
                 UserDefinedConversionAnalysisKind.ApplicableInNormalForm,
+                constrainedToTypeOpt,
                 op,
                 sourceConversion,
                 targetConversion,
@@ -43,6 +46,7 @@ public static UserDefinedConversionAnalysis Normal(
         }
 
         public static UserDefinedConversionAnalysis Lifted(
+            TypeParameterSymbol constrainedToTypeOpt,
             MethodSymbol op,
             Conversion sourceConversion,
             Conversion targetConversion,
@@ -51,6 +55,7 @@ public static UserDefinedConversionAnalysis Lifted(
         {
             return new UserDefinedConversionAnalysis(
                 UserDefinedConversionAnalysisKind.ApplicableInLiftedForm,
+                constrainedToTypeOpt,
                 op,
                 sourceConversion,
                 targetConversion,
@@ -60,6 +65,7 @@ public static UserDefinedConversionAnalysis Lifted(
 
         private UserDefinedConversionAnalysis(
             UserDefinedConversionAnalysisKind kind,
+            TypeParameterSymbol constrainedToTypeOpt,
             MethodSymbol op,
             Conversion sourceConversion,
             Conversion targetConversion,
@@ -67,6 +73,7 @@ private UserDefinedConversionAnalysis(
             TypeSymbol toType)
         {
             this.Kind = kind;
+            this.ConstrainedToTypeOpt = constrainedToTypeOpt;
             this.Operator = op;
             this.SourceConversion = sourceConversion;
             this.TargetConversion = targetConversion;
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedConversions.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedConversions.cs
index b594d2e69625e..6c28f576c6119 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedConversions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedConversions.cs
@@ -15,8 +15,11 @@ namespace Microsoft.CodeAnalysis.CSharp
 {
     internal partial class ConversionsBase
     {
-        private static TypeSymbol GetUnderlyingEffectiveType(TypeSymbol type, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        public static void AddTypesParticipatingInUserDefinedConversion(ArrayBuilder<TypeSymbol> result, TypeSymbol type, bool includeBaseTypes, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
+            // CONSIDER: These sets are usually small; if they are large then this is an O(n^2)
+            // CONSIDER: algorithm. We could use a hash table instead to build up the set.
+
             // Spec 6.4.4: User-defined implicit conversions 
             // Spec 6.4.5: User-defined explicit conversions 
             // 
@@ -24,57 +27,80 @@ private static TypeSymbol GetUnderlyingEffectiveType(TypeSymbol type, ref Compou
             //   * If S or T are nullable types, let Su and Tu be their underlying types, otherwise let Su and Tu be S and T, respectively. 
             //   * If Su or Tu are type parameters, S0 and T0 are their effective base types, otherwise S0 and T0 are equal to Su and Tu, respectively.
 
-            if ((object)type != null)
-            {
-                type = type.StrippedType();
-
-                if (type.IsTypeParameter())
-                {
-                    type = ((TypeParameterSymbol)type).EffectiveBaseClass(ref useSiteInfo);
-                }
-            }
+            // Spec 6.4.4: User-defined implicit conversions
+            //   Find the set of types D from which user-defined conversion operators
+            //   will be considered. This set consists of S0 (if S0 is a class or struct),
+            //   the base classes of S0 (if S0 is a class), and T0 (if T0 is a class or struct).
+            //
+            // Spec 6.4.5: User-defined explicit conversions
+            //   Find the set of types, D, from which user-defined conversion operators will be considered. 
+            //   This set consists of S0 (if S0 is a class or struct), the base classes of S0 (if S0 is a class),
+            //   T0 (if T0 is a class or struct), and the base classes of T0 (if T0 is a class).
 
-            return type;
-        }
+            // https://github.com/dotnet/roslyn/issues/53798: Adjust the above specification quote appropriately.
 
-        public static void AddTypesParticipatingInUserDefinedConversion(ArrayBuilder<NamedTypeSymbol> result, TypeSymbol type, bool includeBaseTypes, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
-        {
             if ((object)type == null)
             {
                 return;
             }
 
-            // CONSIDER: These sets are usually small; if they are large then this is an O(n^2)
-            // CONSIDER: algorithm. We could use a hash table instead to build up the set.
-
-            Debug.Assert(!type.IsTypeParameter());
+            type = type.StrippedType();
 
             // optimization:
             bool excludeExisting = result.Count > 0;
 
-            if (type.IsClassType() || type.IsStructType())
+            if (type is TypeParameterSymbol typeParameter)
             {
-                var namedType = (NamedTypeSymbol)type;
-                if (!excludeExisting || !HasIdentityConversionToAny(namedType, result))
+                NamedTypeSymbol effectiveBaseClass = typeParameter.EffectiveBaseClass(ref useSiteInfo);
+
+                addFromClassOrStruct(result, excludeExisting, effectiveBaseClass, includeBaseTypes, ref useSiteInfo);
+
+                switch (effectiveBaseClass.SpecialType)
                 {
-                    result.Add(namedType);
+                    case SpecialType.System_ValueType:
+                    case SpecialType.System_Enum:
+                    case SpecialType.System_Array:
+                    case SpecialType.System_Object:
+                        if (!excludeExisting || !HasIdentityConversionToAny(typeParameter, result))
+                        {
+                            // Add the type parameter to the set as well. This will be treated equivalent to adding its 
+                            // effective interfaces to the set. We are not doing that here because we still need to know 
+                            // the originating type parameter as "constrained to" type.
+                            result.Add(typeParameter);
+                        }
+                        break;
                 }
             }
-
-            if (!includeBaseTypes)
+            else
             {
-                return;
+                addFromClassOrStruct(result, excludeExisting, type, includeBaseTypes, ref useSiteInfo);
             }
 
-            NamedTypeSymbol t = type.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteInfo);
-            while ((object)t != null)
+            static void addFromClassOrStruct(ArrayBuilder<TypeSymbol> result, bool excludeExisting, TypeSymbol type, bool includeBaseTypes, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
             {
-                if (!excludeExisting || !HasIdentityConversionToAny(t, result))
+                if (type.IsClassType() || type.IsStructType())
                 {
-                    result.Add(t);
+                    if (!excludeExisting || !HasIdentityConversionToAny(type, result))
+                    {
+                        result.Add(type);
+                    }
                 }
 
-                t = t.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteInfo);
+                if (!includeBaseTypes)
+                {
+                    return;
+                }
+
+                NamedTypeSymbol t = type.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteInfo);
+                while ((object)t != null)
+                {
+                    if (!excludeExisting || !HasIdentityConversionToAny(t, result))
+                    {
+                        result.Add(t);
+                    }
+
+                    t = t.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteInfo);
+                }
             }
         }
     }
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedExplicitConversions.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedExplicitConversions.cs
index ae5d2e54b7ec5..63aa33c7cd866 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedExplicitConversions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedExplicitConversions.cs
@@ -31,7 +31,7 @@ private UserDefinedConversionResult AnalyzeExplicitUserDefinedConversions(
 
             // SPEC: Find the set of types D from which user-defined conversion operators
             // SPEC: will be considered...
-            var d = ArrayBuilder<NamedTypeSymbol>.GetInstance();
+            var d = ArrayBuilder<TypeSymbol>.GetInstance();
             ComputeUserDefinedExplicitConversionTypeSet(source, target, d, ref useSiteInfo);
 
             // SPEC: Find the set of applicable user-defined and lifted conversion operators, U...
@@ -69,25 +69,22 @@ private UserDefinedConversionResult AnalyzeExplicitUserDefinedConversions(
             return UserDefinedConversionResult.Valid(u, best.Value);
         }
 
-        private static void ComputeUserDefinedExplicitConversionTypeSet(TypeSymbol source, TypeSymbol target, ArrayBuilder<NamedTypeSymbol> d, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        private static void ComputeUserDefinedExplicitConversionTypeSet(TypeSymbol source, TypeSymbol target, ArrayBuilder<TypeSymbol> d, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
-            TypeSymbol s0 = GetUnderlyingEffectiveType(source, ref useSiteInfo);
-            TypeSymbol t0 = GetUnderlyingEffectiveType(target, ref useSiteInfo);
-
             // Spec 6.4.5: User-defined explicit conversions
             //   Find the set of types, D, from which user-defined conversion operators will be considered. 
             //   This set consists of S0 (if S0 is a class or struct), the base classes of S0 (if S0 is a class),
             //   T0 (if T0 is a class or struct), and the base classes of T0 (if T0 is a class).
 
-            AddTypesParticipatingInUserDefinedConversion(d, s0, includeBaseTypes: true, useSiteInfo: ref useSiteInfo);
-            AddTypesParticipatingInUserDefinedConversion(d, t0, includeBaseTypes: true, useSiteInfo: ref useSiteInfo);
+            AddTypesParticipatingInUserDefinedConversion(d, source, includeBaseTypes: true, useSiteInfo: ref useSiteInfo);
+            AddTypesParticipatingInUserDefinedConversion(d, target, includeBaseTypes: true, useSiteInfo: ref useSiteInfo);
         }
 
         private void ComputeApplicableUserDefinedExplicitConversionSet(
             BoundExpression sourceExpression,
             TypeSymbol source,
             TypeSymbol target,
-            ArrayBuilder<NamedTypeSymbol> d,
+            ArrayBuilder<TypeSymbol> d,
             ArrayBuilder<UserDefinedConversionAnalysis> u,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
@@ -96,10 +93,44 @@ private void ComputeApplicableUserDefinedExplicitConversionSet(
             Debug.Assert(d != null);
             Debug.Assert(u != null);
 
-            foreach (NamedTypeSymbol declaringType in d)
+            HashSet<NamedTypeSymbol> lookedInInterfaces = null;
+
+            foreach (TypeSymbol declaringType in d)
+            {
+                if (declaringType is TypeParameterSymbol typeParameter)
+                {
+                    ImmutableArray<NamedTypeSymbol> interfaceTypes = typeParameter.AllEffectiveInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteInfo);
+
+                    if (!interfaceTypes.IsEmpty)
+                    {
+                        lookedInInterfaces ??= new HashSet<NamedTypeSymbol>(Symbols.SymbolEqualityComparer.AllIgnoreOptions); // Equivalent to has identity conversion check
+
+                        foreach (var interfaceType in interfaceTypes)
+                        {
+                            if (lookedInInterfaces.Add(interfaceType))
+                            {
+                                addCandidatesFromType(constrainedToTypeOpt: typeParameter, interfaceType, sourceExpression, source, target, u, ref useSiteInfo);
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    addCandidatesFromType(constrainedToTypeOpt: null, (NamedTypeSymbol)declaringType, sourceExpression, source, target, u, ref useSiteInfo);
+                }
+            }
+
+            void addCandidatesFromType(
+                TypeParameterSymbol constrainedToTypeOpt,
+                NamedTypeSymbol declaringType,
+                BoundExpression sourceExpression,
+                TypeSymbol source,
+                TypeSymbol target,
+                ArrayBuilder<UserDefinedConversionAnalysis> u,
+                ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
             {
-                AddUserDefinedConversionsToExplicitCandidateSet(sourceExpression, source, target, u, declaringType, WellKnownMemberNames.ExplicitConversionName, ref useSiteInfo);
-                AddUserDefinedConversionsToExplicitCandidateSet(sourceExpression, source, target, u, declaringType, WellKnownMemberNames.ImplicitConversionName, ref useSiteInfo);
+                AddUserDefinedConversionsToExplicitCandidateSet(sourceExpression, source, target, u, constrainedToTypeOpt, declaringType, WellKnownMemberNames.ExplicitConversionName, ref useSiteInfo);
+                AddUserDefinedConversionsToExplicitCandidateSet(sourceExpression, source, target, u, constrainedToTypeOpt, declaringType, WellKnownMemberNames.ImplicitConversionName, ref useSiteInfo);
             }
         }
 
@@ -108,6 +139,7 @@ private void AddUserDefinedConversionsToExplicitCandidateSet(
             TypeSymbol source,
             TypeSymbol target,
             ArrayBuilder<UserDefinedConversionAnalysis> u,
+            TypeParameterSymbol constrainedToTypeOpt,
             NamedTypeSymbol declaringType,
             string operatorName,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
@@ -241,7 +273,7 @@ private void AddUserDefinedConversionsToExplicitCandidateSet(
                         Conversion liftedToConversion = EncompassingExplicitConversion(null, nullableTo, target, ref useSiteInfo);
                         Debug.Assert(liftedFromConversion.Exists);
                         Debug.Assert(liftedToConversion.Exists);
-                        u.Add(UserDefinedConversionAnalysis.Lifted(op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo));
+                        u.Add(UserDefinedConversionAnalysis.Lifted(constrainedToTypeOpt, op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo));
                     }
                     else
                     {
@@ -272,7 +304,7 @@ private void AddUserDefinedConversionsToExplicitCandidateSet(
                             fromConversion = EncompassingExplicitConversion(null, convertsFrom, source, ref useSiteInfo);
                         }
 
-                        u.Add(UserDefinedConversionAnalysis.Normal(op, fromConversion, toConversion, convertsFrom, convertsTo));
+                        u.Add(UserDefinedConversionAnalysis.Normal(constrainedToTypeOpt, op, fromConversion, toConversion, convertsFrom, convertsTo));
                     }
                 }
             }
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedImplicitConversions.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedImplicitConversions.cs
index 63ce6a34148aa..4bc7e128466c8 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedImplicitConversions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/UserDefinedImplicitConversions.cs
@@ -76,7 +76,7 @@ private UserDefinedConversionResult AnalyzeImplicitUserDefinedConversions(
             //   A user-defined implicit conversion from an expression E to type T is processed as follows:
 
             // SPEC: Find the set of types D from which user-defined conversion operators...
-            var d = ArrayBuilder<NamedTypeSymbol>.GetInstance();
+            var d = ArrayBuilder<TypeSymbol>.GetInstance();
             ComputeUserDefinedImplicitConversionTypeSet(source, target, d, ref useSiteInfo);
 
             // SPEC: Find the set of applicable user-defined and lifted conversion operators, U...
@@ -114,18 +114,15 @@ private UserDefinedConversionResult AnalyzeImplicitUserDefinedConversions(
             return UserDefinedConversionResult.Valid(u, best.Value);
         }
 
-        private static void ComputeUserDefinedImplicitConversionTypeSet(TypeSymbol s, TypeSymbol t, ArrayBuilder<NamedTypeSymbol> d, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        private static void ComputeUserDefinedImplicitConversionTypeSet(TypeSymbol s, TypeSymbol t, ArrayBuilder<TypeSymbol> d, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             // Spec 6.4.4: User-defined implicit conversions
             //   Find the set of types D from which user-defined conversion operators
             //   will be considered. This set consists of S0 (if S0 is a class or struct),
             //   the base classes of S0 (if S0 is a class), and T0 (if T0 is a class or struct).
 
-            TypeSymbol s0 = GetUnderlyingEffectiveType(s, ref useSiteInfo);
-            TypeSymbol t0 = GetUnderlyingEffectiveType(t, ref useSiteInfo);
-
-            AddTypesParticipatingInUserDefinedConversion(d, s0, includeBaseTypes: true, useSiteInfo: ref useSiteInfo);
-            AddTypesParticipatingInUserDefinedConversion(d, t0, includeBaseTypes: false, useSiteInfo: ref useSiteInfo);
+            AddTypesParticipatingInUserDefinedConversion(d, s, includeBaseTypes: true, useSiteInfo: ref useSiteInfo);
+            AddTypesParticipatingInUserDefinedConversion(d, t, includeBaseTypes: false, useSiteInfo: ref useSiteInfo);
         }
 
         /// <summary>
@@ -145,7 +142,7 @@ private void ComputeApplicableUserDefinedImplicitConversionSet(
             BoundExpression sourceExpression,
             TypeSymbol source,
             TypeSymbol target,
-            ArrayBuilder<NamedTypeSymbol> d,
+            ArrayBuilder<TypeSymbol> d,
             ArrayBuilder<UserDefinedConversionAnalysis> u,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo,
             bool allowAnyTarget = false)
@@ -246,7 +243,42 @@ private void ComputeApplicableUserDefinedImplicitConversionSet(
                 return;
             }
 
-            foreach (NamedTypeSymbol declaringType in d)
+            HashSet<NamedTypeSymbol> lookedInInterfaces = null;
+
+            foreach (TypeSymbol declaringType in d)
+            {
+                if (declaringType is TypeParameterSymbol typeParameter)
+                {
+                    ImmutableArray<NamedTypeSymbol> interfaceTypes = typeParameter.AllEffectiveInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteInfo);
+
+                    if (!interfaceTypes.IsEmpty)
+                    {
+                        lookedInInterfaces ??= new HashSet<NamedTypeSymbol>(Symbols.SymbolEqualityComparer.AllIgnoreOptions); // Equivalent to has identity conversion check
+
+                        foreach (var interfaceType in interfaceTypes)
+                        {
+                            if (lookedInInterfaces.Add(interfaceType))
+                            {
+                                addCandidatesFromType(constrainedToTypeOpt: typeParameter, interfaceType, sourceExpression, source, target, u, ref useSiteInfo, allowAnyTarget);
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    addCandidatesFromType(constrainedToTypeOpt: null, (NamedTypeSymbol)declaringType, sourceExpression, source, target, u, ref useSiteInfo, allowAnyTarget);
+                }
+            }
+
+            void addCandidatesFromType(
+                TypeParameterSymbol constrainedToTypeOpt,
+                NamedTypeSymbol declaringType,
+                BoundExpression sourceExpression,
+                TypeSymbol source,
+                TypeSymbol target,
+                ArrayBuilder<UserDefinedConversionAnalysis> u,
+                ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo,
+                bool allowAnyTarget)
             {
                 foreach (MethodSymbol op in declaringType.GetOperators(WellKnownMemberNames.ImplicitConversionName))
                 {
@@ -281,7 +313,7 @@ private void ComputeApplicableUserDefinedImplicitConversionSet(
                                 EncompassingImplicitConversion(null, convertsTo, target, ref useSiteInfo);
                         }
 
-                        u.Add(UserDefinedConversionAnalysis.Normal(op, fromConversion, toConversion, convertsFrom, convertsTo));
+                        u.Add(UserDefinedConversionAnalysis.Normal(constrainedToTypeOpt, op, fromConversion, toConversion, convertsFrom, convertsTo));
                     }
                     else if ((object)source != null && source.IsNullableType() && convertsFrom.IsNonNullableValueType() &&
                         (allowAnyTarget || target.CanBeAssignedNull()))
@@ -309,7 +341,7 @@ private void ComputeApplicableUserDefinedImplicitConversionSet(
                             Conversion.Identity;
                         if (liftedFromConversion.Exists && liftedToConversion.Exists)
                         {
-                            u.Add(UserDefinedConversionAnalysis.Lifted(op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo));
+                            u.Add(UserDefinedConversionAnalysis.Lifted(constrainedToTypeOpt, op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo));
                         }
                     }
                 }
@@ -889,7 +921,7 @@ protected UserDefinedConversionResult AnalyzeImplicitUserDefinedConversionForV6S
             // SPEC VIOLATION: We do the same to maintain compatibility with the native compiler.
 
             // (a) Compute the set of types D from which user-defined conversion operators should be considered by considering only the source type.
-            var d = ArrayBuilder<NamedTypeSymbol>.GetInstance();
+            var d = ArrayBuilder<TypeSymbol>.GetInstance();
             ComputeUserDefinedImplicitConversionTypeSet(source, t: null, d: d, useSiteInfo: ref useSiteInfo);
 
             // (b) Instead of computing applicable user defined implicit conversions U from the source type to a specific target type,
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorOverloadResolution.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorOverloadResolution.cs
index 81ba41a7dbe20..77c94f0db82a2 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorOverloadResolution.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorOverloadResolution.cs
@@ -111,29 +111,47 @@ internal void BinaryOperatorOverloadResolution_NoEasyOut(BinaryOperatorKind kind
             Debug.Assert((result.Results.Count == 0) != hadApplicableCandidates);
 
             // If there are no applicable candidates in classes / stuctures, try with interface sources.
-            // From https://github.com/dotnet/csharplang/blob/main/meetings/2017/LDM-2017-06-27.md:
-            // We do not allow == and != and. Otherwise, there'd be no way to override Equals and GetHashCode,
-            // so you couldn't do == and != in a recommended way.
-            if (!hadApplicableCandidates &&
-                kind != BinaryOperatorKind.Equal && kind != BinaryOperatorKind.NotEqual)
+            if (!hadApplicableCandidates)
             {
                 result.Results.Clear();
 
                 string name = OperatorFacts.BinaryOperatorNameFromOperatorKind(kind);
                 var lookedInInterfaces = PooledDictionary<TypeSymbol, bool>.GetInstance();
 
+                TypeSymbol firstOperatorSourceOpt;
+                TypeSymbol secondOperatorSourceOpt;
+                bool firstSourceIsInterface;
+                bool secondSourceIsInterface;
+
+                // Always start lookup from a type parameter. This ensures that regardless of the order we always pick up constrained type for
+                // each distinct candidate operator.
+                if (leftOperatorSourceOpt is null || (leftOperatorSourceOpt is not TypeParameterSymbol && rightOperatorSourceOpt is TypeParameterSymbol))
+                {
+                    firstOperatorSourceOpt = rightOperatorSourceOpt;
+                    secondOperatorSourceOpt = leftOperatorSourceOpt;
+                    firstSourceIsInterface = rightSourceIsInterface;
+                    secondSourceIsInterface = leftSourceIsInterface;
+                }
+                else
+                {
+                    firstOperatorSourceOpt = leftOperatorSourceOpt;
+                    secondOperatorSourceOpt = rightOperatorSourceOpt;
+                    firstSourceIsInterface = leftSourceIsInterface;
+                    secondSourceIsInterface = rightSourceIsInterface;
+                }
+
                 hadApplicableCandidates = GetUserDefinedBinaryOperatorsFromInterfaces(kind, name,
-                        leftOperatorSourceOpt, leftSourceIsInterface, left, right, ref useSiteInfo, lookedInInterfaces, result.Results);
+                        firstOperatorSourceOpt, firstSourceIsInterface, left, right, ref useSiteInfo, lookedInInterfaces, result.Results);
                 if (!hadApplicableCandidates)
                 {
                     result.Results.Clear();
                 }
 
-                if ((object)rightOperatorSourceOpt != null && !rightOperatorSourceOpt.Equals(leftOperatorSourceOpt))
+                if ((object)secondOperatorSourceOpt != null && !secondOperatorSourceOpt.Equals(firstOperatorSourceOpt))
                 {
                     var rightOperators = ArrayBuilder<BinaryOperatorAnalysisResult>.GetInstance();
                     if (GetUserDefinedBinaryOperatorsFromInterfaces(kind, name,
-                            rightOperatorSourceOpt, rightSourceIsInterface, left, right, ref useSiteInfo, lookedInInterfaces, rightOperators))
+                            secondOperatorSourceOpt, secondSourceIsInterface, left, right, ref useSiteInfo, lookedInInterfaces, rightOperators))
                     {
                         hadApplicableCandidates = true;
                         AddDistinctOperators(result.Results, rightOperators);
@@ -194,6 +212,7 @@ private bool GetUserDefinedBinaryOperatorsFromInterfaces(BinaryOperatorKind kind
 
             bool hadUserDefinedCandidateFromInterfaces = false;
             ImmutableArray<NamedTypeSymbol> interfaces = default;
+            TypeSymbol constrainedToTypeOpt = null;
 
             if (sourceIsInterface)
             {
@@ -201,7 +220,7 @@ private bool GetUserDefinedBinaryOperatorsFromInterfaces(BinaryOperatorKind kind
                 if (!lookedInInterfaces.TryGetValue(operatorSourceOpt, out _))
                 {
                     var operators = ArrayBuilder<BinaryOperatorSignature>.GetInstance();
-                    GetUserDefinedBinaryOperatorsFromType((NamedTypeSymbol)operatorSourceOpt, kind, name, operators);
+                    GetUserDefinedBinaryOperatorsFromType(constrainedToTypeOpt, (NamedTypeSymbol)operatorSourceOpt, kind, name, operators);
                     hadUserDefinedCandidateFromInterfaces = CandidateOperators(operators, left, right, candidates, ref useSiteInfo);
                     operators.Free();
                     Debug.Assert(hadUserDefinedCandidateFromInterfaces == candidates.Any(r => r.IsValid));
@@ -217,6 +236,7 @@ private bool GetUserDefinedBinaryOperatorsFromInterfaces(BinaryOperatorKind kind
             else if (operatorSourceOpt.IsTypeParameter())
             {
                 interfaces = ((TypeParameterSymbol)operatorSourceOpt).AllEffectiveInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteInfo);
+                constrainedToTypeOpt = operatorSourceOpt;
             }
 
             if (!interfaces.IsDefaultOrEmpty)
@@ -253,7 +273,7 @@ private bool GetUserDefinedBinaryOperatorsFromInterfaces(BinaryOperatorKind kind
 
                     operators.Clear();
                     results.Clear();
-                    GetUserDefinedBinaryOperatorsFromType(@interface, kind, name, operators);
+                    GetUserDefinedBinaryOperatorsFromType(constrainedToTypeOpt, @interface, kind, name, operators);
                     hadUserDefinedCandidate = CandidateOperators(operators, left, right, results, ref useSiteInfo);
                     Debug.Assert(hadUserDefinedCandidate == results.Any(r => r.IsValid));
                     lookedInInterfaces.Add(@interface, hadUserDefinedCandidate);
@@ -832,7 +852,7 @@ private bool GetUserDefinedOperators(
             for (; (object)current != null; current = current.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteInfo))
             {
                 operators.Clear();
-                GetUserDefinedBinaryOperatorsFromType(current, kind, name, operators);
+                GetUserDefinedBinaryOperatorsFromType(constrainedToTypeOpt: null, current, kind, name, operators);
                 results.Clear();
                 if (CandidateOperators(operators, left, right, results, ref useSiteInfo))
                 {
@@ -848,6 +868,7 @@ private bool GetUserDefinedOperators(
         }
 
         private void GetUserDefinedBinaryOperatorsFromType(
+            TypeSymbol constrainedToTypeOpt,
             NamedTypeSymbol type,
             BinaryOperatorKind kind,
             string name,
@@ -865,7 +886,7 @@ private void GetUserDefinedBinaryOperatorsFromType(
                 TypeSymbol rightOperandType = op.GetParameterType(1);
                 TypeSymbol resultType = op.ReturnType;
 
-                operators.Add(new BinaryOperatorSignature(BinaryOperatorKind.UserDefined | kind, leftOperandType, rightOperandType, resultType, op));
+                operators.Add(new BinaryOperatorSignature(BinaryOperatorKind.UserDefined | kind, leftOperandType, rightOperandType, resultType, op, constrainedToTypeOpt));
 
                 LiftingResult lifting = UserDefinedBinaryOperatorCanBeLifted(leftOperandType, rightOperandType, resultType, kind);
 
@@ -873,13 +894,13 @@ private void GetUserDefinedBinaryOperatorsFromType(
                 {
                     operators.Add(new BinaryOperatorSignature(
                         BinaryOperatorKind.Lifted | BinaryOperatorKind.UserDefined | kind,
-                        MakeNullable(leftOperandType), MakeNullable(rightOperandType), MakeNullable(resultType), op));
+                        MakeNullable(leftOperandType), MakeNullable(rightOperandType), MakeNullable(resultType), op, constrainedToTypeOpt));
                 }
                 else if (lifting == LiftingResult.LiftOperandsButNotResult)
                 {
                     operators.Add(new BinaryOperatorSignature(
                         BinaryOperatorKind.Lifted | BinaryOperatorKind.UserDefined | kind,
-                        MakeNullable(leftOperandType), MakeNullable(rightOperandType), resultType, op));
+                        MakeNullable(leftOperandType), MakeNullable(rightOperandType), resultType, op, constrainedToTypeOpt));
                 }
             }
         }
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorSignature.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorSignature.cs
index d406f5ecda199..ed0cc94d016ad 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorSignature.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorSignature.cs
@@ -19,6 +19,7 @@ internal struct BinaryOperatorSignature : IEquatable<BinaryOperatorSignature>
         public readonly TypeSymbol RightType;
         public readonly TypeSymbol ReturnType;
         public readonly MethodSymbol Method;
+        public readonly TypeSymbol ConstrainedToTypeOpt;
         public readonly BinaryOperatorKind Kind;
 
         /// <summary>
@@ -28,13 +29,25 @@ internal struct BinaryOperatorSignature : IEquatable<BinaryOperatorSignature>
         /// </summary>
         public int? Priority;
 
-        public BinaryOperatorSignature(BinaryOperatorKind kind, TypeSymbol leftType, TypeSymbol rightType, TypeSymbol returnType, MethodSymbol method = null)
+        public BinaryOperatorSignature(BinaryOperatorKind kind, TypeSymbol leftType, TypeSymbol rightType, TypeSymbol returnType)
+        {
+            this.Kind = kind;
+            this.LeftType = leftType;
+            this.RightType = rightType;
+            this.ReturnType = returnType;
+            this.Method = null;
+            this.ConstrainedToTypeOpt = null;
+            this.Priority = null;
+        }
+
+        public BinaryOperatorSignature(BinaryOperatorKind kind, TypeSymbol leftType, TypeSymbol rightType, TypeSymbol returnType, MethodSymbol method, TypeSymbol constrainedToTypeOpt)
         {
             this.Kind = kind;
             this.LeftType = leftType;
             this.RightType = rightType;
             this.ReturnType = returnType;
             this.Method = method;
+            this.ConstrainedToTypeOpt = constrainedToTypeOpt;
             this.Priority = null;
         }
 
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/OperatorFacts.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/OperatorFacts.cs
index c79253e2961bd..870595ae6028c 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/OperatorFacts.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/OperatorFacts.cs
@@ -145,6 +145,22 @@ public static string OperatorNameFromDeclaration(Syntax.InternalSyntax.OperatorD
             }
         }
 
+        public static string OperatorNameFromDeclaration(ConversionOperatorDeclarationSyntax declaration)
+        {
+            return OperatorNameFromDeclaration((Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax)(declaration.Green));
+        }
+
+        public static string OperatorNameFromDeclaration(Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax declaration)
+        {
+            switch (declaration.ImplicitOrExplicitKeyword.Kind)
+            {
+                case SyntaxKind.ImplicitKeyword:
+                    return WellKnownMemberNames.ImplicitConversionName;
+                default:
+                    return WellKnownMemberNames.ExplicitConversionName;
+            }
+        }
+
         public static string UnaryOperatorNameFromOperatorKind(UnaryOperatorKind kind)
         {
             switch (kind & UnaryOperatorKind.OpMask)
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/UnaryOperatorOverloadResolution.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/UnaryOperatorOverloadResolution.cs
index e4341aa2b59b7..68f3de987afe9 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/UnaryOperatorOverloadResolution.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/UnaryOperatorOverloadResolution.cs
@@ -375,6 +375,7 @@ private bool GetUserDefinedOperators(UnaryOperatorKind kind, BoundExpression ope
             // we stop looking.
 
             TypeSymbol type0 = operand.Type.StrippedType();
+            TypeSymbol constrainedToTypeOpt = type0 as TypeParameterSymbol;
 
             // Searching for user-defined operators is expensive; let's take an early out if we can.
             if (OperatorFacts.DefinitelyHasNoUserDefinedOperators(type0))
@@ -400,7 +401,7 @@ private bool GetUserDefinedOperators(UnaryOperatorKind kind, BoundExpression ope
             for (; (object)current != null; current = current.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteInfo))
             {
                 operators.Clear();
-                GetUserDefinedUnaryOperatorsFromType(current, kind, name, operators);
+                GetUserDefinedUnaryOperatorsFromType(constrainedToTypeOpt, current, kind, name, operators);
                 results.Clear();
                 if (CandidateOperators(operators, operand, results, ref useSiteInfo))
                 {
@@ -444,7 +445,7 @@ private bool GetUserDefinedOperators(UnaryOperatorKind kind, BoundExpression ope
 
                         operators.Clear();
                         resultsFromInterface.Clear();
-                        GetUserDefinedUnaryOperatorsFromType(@interface, kind, name, operators);
+                        GetUserDefinedUnaryOperatorsFromType(constrainedToTypeOpt, @interface, kind, name, operators);
                         if (CandidateOperators(operators, operand, resultsFromInterface, ref useSiteInfo))
                         {
                             hadApplicableCandidates = true;
@@ -466,6 +467,7 @@ private bool GetUserDefinedOperators(UnaryOperatorKind kind, BoundExpression ope
         }
 
         private void GetUserDefinedUnaryOperatorsFromType(
+            TypeSymbol constrainedToTypeOpt,
             NamedTypeSymbol type,
             UnaryOperatorKind kind,
             string name,
@@ -482,7 +484,7 @@ private void GetUserDefinedUnaryOperatorsFromType(
                 TypeSymbol operandType = op.GetParameterType(0);
                 TypeSymbol resultType = op.ReturnType;
 
-                operators.Add(new UnaryOperatorSignature(UnaryOperatorKind.UserDefined | kind, operandType, resultType, op));
+                operators.Add(new UnaryOperatorSignature(UnaryOperatorKind.UserDefined | kind, operandType, resultType, op, constrainedToTypeOpt));
 
                 // SPEC: For the unary operators + ++ - -- ! ~ a lifted form of an operator exists
                 // SPEC: if the operand and its result types are both non-nullable value types.
@@ -503,7 +505,7 @@ private void GetUserDefinedUnaryOperatorsFromType(
                         {
                             operators.Add(new UnaryOperatorSignature(
                                 UnaryOperatorKind.Lifted | UnaryOperatorKind.UserDefined | kind,
-                                MakeNullable(operandType), MakeNullable(resultType), op));
+                                MakeNullable(operandType), MakeNullable(resultType), op, constrainedToTypeOpt));
                         }
                         break;
                 }
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/UnaryOperatorSignature.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/UnaryOperatorSignature.cs
index 865a30b4ccaf7..b646f848a65e9 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/UnaryOperatorSignature.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/UnaryOperatorSignature.cs
@@ -15,16 +15,27 @@ internal struct UnaryOperatorSignature
         public static UnaryOperatorSignature Error = default(UnaryOperatorSignature);
 
         public readonly MethodSymbol Method;
+        public readonly TypeSymbol ConstrainedToTypeOpt;
         public readonly TypeSymbol OperandType;
         public readonly TypeSymbol ReturnType;
         public readonly UnaryOperatorKind Kind;
 
-        public UnaryOperatorSignature(UnaryOperatorKind kind, TypeSymbol operandType, TypeSymbol returnType, MethodSymbol method = null)
+        public UnaryOperatorSignature(UnaryOperatorKind kind, TypeSymbol operandType, TypeSymbol returnType)
+        {
+            this.Kind = kind;
+            this.OperandType = operandType;
+            this.ReturnType = returnType;
+            this.Method = null;
+            this.ConstrainedToTypeOpt = null;
+        }
+
+        public UnaryOperatorSignature(UnaryOperatorKind kind, TypeSymbol operandType, TypeSymbol returnType, MethodSymbol method, TypeSymbol constrainedToTypeOpt)
         {
             this.Kind = kind;
             this.OperandType = operandType;
             this.ReturnType = returnType;
             this.Method = method;
+            this.ConstrainedToTypeOpt = constrainedToTypeOpt;
         }
 
         public override string ToString()
diff --git a/src/Compilers/CSharp/Portable/Binder/WithLambdaParametersBinder.cs b/src/Compilers/CSharp/Portable/Binder/WithLambdaParametersBinder.cs
index e6ee9f1727492..1db796a46d6db 100644
--- a/src/Compilers/CSharp/Portable/Binder/WithLambdaParametersBinder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/WithLambdaParametersBinder.cs
@@ -5,7 +5,6 @@
 #nullable disable
 
 using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -18,7 +17,7 @@ internal class WithLambdaParametersBinder : LocalScopeBinder
     {
         protected readonly LambdaSymbol lambdaSymbol;
         protected readonly MultiDictionary<string, ParameterSymbol> parameterMap;
-        private SmallDictionary<string, ParameterSymbol> _definitionMap;
+        private readonly SmallDictionary<string, ParameterSymbol> _definitionMap;
 
         public WithLambdaParametersBinder(LambdaSymbol lambdaSymbol, Binder enclosing)
             : base(enclosing)
@@ -29,24 +28,17 @@ public WithLambdaParametersBinder(LambdaSymbol lambdaSymbol, Binder enclosing)
             var parameters = lambdaSymbol.Parameters;
             if (!parameters.IsDefaultOrEmpty)
             {
-                recordDefinitions(parameters);
-                foreach (var parameter in lambdaSymbol.Parameters)
+                _definitionMap = new SmallDictionary<string, ParameterSymbol>();
+                foreach (var parameter in parameters)
                 {
                     if (!parameter.IsDiscard)
                     {
-                        this.parameterMap.Add(parameter.Name, parameter);
-                    }
-                }
-            }
-
-            void recordDefinitions(ImmutableArray<ParameterSymbol> definitions)
-            {
-                var declarationMap = _definitionMap ??= new SmallDictionary<string, ParameterSymbol>();
-                foreach (var s in definitions)
-                {
-                    if (!s.IsDiscard && !declarationMap.ContainsKey(s.Name))
-                    {
-                        declarationMap.Add(s.Name, s);
+                        var name = parameter.Name;
+                        this.parameterMap.Add(name, parameter);
+                        if (!_definitionMap.ContainsKey(name))
+                        {
+                            _definitionMap.Add(name, parameter);
+                        }
                     }
                 }
             }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index 438e5217fe861..866232c11182f 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -281,6 +281,7 @@
     <Field Name="Operand" Type="BoundExpression"/>
     <Field Name="ConstantValueOpt" Type="ConstantValue?"/>
     <Field Name="MethodOpt" Type="MethodSymbol?"/>
+    <Field Name="ConstrainedToTypeOpt" Type="TypeSymbol?" Null="allow"/>
     <Field Name="ResultKind" PropertyOverrides="true" Type="LookupResultKind"/>
     <!--The set of method symbols from which this operator's method was chosen.
         Only kept in the tree if the operator was an error and overload resolution
@@ -296,6 +297,7 @@
     <Field Name="OperatorKind" Type="UnaryOperatorKind"/>
     <Field Name="Operand" Type="BoundExpression"/>
     <Field Name="MethodOpt" Type="MethodSymbol?"/>
+    <Field Name="ConstrainedToTypeOpt" Type="TypeSymbol?" Null="allow"/>
     <Field Name="OperandConversion" Type="Conversion"/>
     <Field Name="ResultConversion" Type="Conversion"/>
     <Field Name="ResultKind" PropertyOverrides="true" Type="LookupResultKind"/>
@@ -332,6 +334,7 @@
   <!-- Represents a resolved AddressOf function pointer. Not used in initial binding. -->
   <Node Name="BoundFunctionPointerLoad" Base="BoundExpression">
     <Field Name="TargetMethod" Type="MethodSymbol"/>
+    <Field Name="ConstrainedToTypeOpt" Type="TypeSymbol?" Null="allow"/>
     <!-- Non-null type is required for this node kind -->
     <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
   </Node>
@@ -404,6 +407,7 @@
     <Field Name="OperatorKind" Type="BinaryOperatorKind"/>
     <Field Name="ConstantValueOpt" Type="ConstantValue?"/>
     <Field Name="MethodOpt" Type="MethodSymbol?"/>
+    <Field Name="ConstrainedToTypeOpt" Type="TypeSymbol?" Null="allow"/>
     <Field Name="ResultKind" PropertyOverrides="true" Type="LookupResultKind"/>
     <!--The set of method symbols from which this operator's method was chosen.
         Only kept in the tree if the operator was an error and overload resolution
@@ -425,6 +429,7 @@
     <Field Name="LogicalOperator" Type="MethodSymbol"/>
     <Field Name="TrueOperator" Type="MethodSymbol"/>
     <Field Name="FalseOperator" Type="MethodSymbol"/>
+    <Field Name="ConstrainedToTypeOpt" Type="TypeSymbol?" Null="allow"/>
     <Field Name="ResultKind" PropertyOverrides="true" Type="LookupResultKind"/>
     <!--The set of method symbols from which this operator's method was chosen.
         Only kept in the tree if the operator was an error and overload resolution
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundTreeRewriter.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundTreeRewriter.cs
index 6b46b45cc5102..402eb6e7d8336 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundTreeRewriter.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundTreeRewriter.cs
@@ -142,7 +142,7 @@ protected BoundTreeRewriterWithStackGuardWithoutRecursionOnTheLeftOfBinaryOperat
                 var right = (BoundExpression?)this.Visit(binary.Right);
                 Debug.Assert(right is { });
                 var type = this.VisitType(binary.Type);
-                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.MethodOpt, binary.ResultKind, binary.OriginalUserDefinedOperatorsOpt, left, right, type);
+                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.MethodOpt, binary.ConstrainedToTypeOpt, binary.ResultKind, binary.OriginalUserDefinedOperatorsOpt, left, right, type);
             }
             while (stack.Count > 0);
 
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
index 4215d0e944d51..ac972120761df 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
@@ -374,6 +374,7 @@ public BoundBinaryOperator(
             BoundExpression right,
             ConstantValue? constantValueOpt,
             MethodSymbol? methodOpt,
+            TypeSymbol? constrainedToTypeOpt,
             LookupResultKind resultKind,
             ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt,
             TypeSymbol type,
@@ -383,6 +384,7 @@ public BoundBinaryOperator(
                 operatorKind,
                 constantValueOpt,
                 methodOpt,
+                constrainedToTypeOpt,
                 resultKind,
                 originalUserDefinedOperatorsOpt,
                 left,
@@ -396,23 +398,25 @@ public BoundBinaryOperator(
             BinaryOperatorKind operatorKind,
             ConstantValue? constantValueOpt,
             MethodSymbol? methodOpt,
+            TypeSymbol? constrainedToTypeOpt,
             LookupResultKind resultKind,
             BoundExpression left,
             BoundExpression right,
             TypeSymbol type,
             bool hasErrors = false) :
-            this(syntax, operatorKind, constantValueOpt, methodOpt, resultKind, originalUserDefinedOperatorsOpt: default, left, right, type, hasErrors)
+            this(syntax, operatorKind, constantValueOpt, methodOpt, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt: default, left, right, type, hasErrors)
         {
         }
 
         public BoundBinaryOperator Update(BinaryOperatorKind operatorKind,
                                           ConstantValue? constantValueOpt,
                                           MethodSymbol? methodOpt,
+                                          TypeSymbol? constrainedToTypeOpt,
                                           LookupResultKind resultKind,
                                           BoundExpression left,
                                           BoundExpression right,
                                           TypeSymbol type)
-            => Update(operatorKind, constantValueOpt, methodOpt, resultKind, this.OriginalUserDefinedOperatorsOpt, left, right, type);
+            => Update(operatorKind, constantValueOpt, methodOpt, constrainedToTypeOpt, resultKind, this.OriginalUserDefinedOperatorsOpt, left, right, type);
     }
 
     internal sealed partial class BoundUserDefinedConditionalLogicalOperator
@@ -425,6 +429,7 @@ public BoundUserDefinedConditionalLogicalOperator(
             MethodSymbol logicalOperator,
             MethodSymbol trueOperator,
             MethodSymbol falseOperator,
+            TypeSymbol? constrainedToTypeOpt,
             LookupResultKind resultKind,
             ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt,
             TypeSymbol type,
@@ -435,6 +440,7 @@ public BoundUserDefinedConditionalLogicalOperator(
                 logicalOperator,
                 trueOperator,
                 falseOperator,
+                constrainedToTypeOpt,
                 resultKind,
                 originalUserDefinedOperatorsOpt,
                 left,
@@ -449,11 +455,12 @@ public BoundUserDefinedConditionalLogicalOperator Update(BinaryOperatorKind oper
                                                                  MethodSymbol logicalOperator,
                                                                  MethodSymbol trueOperator,
                                                                  MethodSymbol falseOperator,
+                                                                 TypeSymbol? constrainedToTypeOpt,
                                                                  LookupResultKind resultKind,
                                                                  BoundExpression left,
                                                                  BoundExpression right,
                                                                  TypeSymbol type)
-            => Update(operatorKind, logicalOperator, trueOperator, falseOperator, resultKind, this.OriginalUserDefinedOperatorsOpt, left, right, type);
+            => Update(operatorKind, logicalOperator, trueOperator, falseOperator, constrainedToTypeOpt, resultKind, this.OriginalUserDefinedOperatorsOpt, left, right, type);
     }
 
     internal sealed partial class BoundParameter
@@ -673,10 +680,11 @@ public BoundUnaryOperator(
             BoundExpression operand,
             ConstantValue? constantValueOpt,
             MethodSymbol? methodOpt,
+            TypeSymbol? constrainedToTypeOpt,
             LookupResultKind resultKind,
             TypeSymbol type,
             bool hasErrors = false) :
-            this(syntax, operatorKind, operand, constantValueOpt, methodOpt, resultKind, originalUserDefinedOperatorsOpt: default, type, hasErrors)
+            this(syntax, operatorKind, operand, constantValueOpt, methodOpt, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt: default, type, hasErrors)
         {
         }
 
@@ -684,9 +692,10 @@ public BoundUnaryOperator Update(UnaryOperatorKind operatorKind,
                                          BoundExpression operand,
                                          ConstantValue? constantValueOpt,
                                          MethodSymbol? methodOpt,
+                                         TypeSymbol? constrainedToTypeOpt,
                                          LookupResultKind resultKind,
                                          TypeSymbol type)
-            => Update(operatorKind, operand, constantValueOpt, methodOpt, resultKind, this.OriginalUserDefinedOperatorsOpt, type);
+            => Update(operatorKind, operand, constantValueOpt, methodOpt, constrainedToTypeOpt, resultKind, this.OriginalUserDefinedOperatorsOpt, type);
     }
 
     internal partial class BoundIncrementOperator
@@ -696,18 +705,19 @@ public BoundIncrementOperator(
             UnaryOperatorKind operatorKind,
             BoundExpression operand,
             MethodSymbol? methodOpt,
+            TypeSymbol? constrainedToTypeOpt,
             Conversion operandConversion,
             Conversion resultConversion,
             LookupResultKind resultKind,
             TypeSymbol type,
             bool hasErrors = false) :
-            this(syntax, operatorKind, operand, methodOpt, operandConversion, resultConversion, resultKind, originalUserDefinedOperatorsOpt: default, type, hasErrors)
+            this(syntax, operatorKind, operand, methodOpt, constrainedToTypeOpt, operandConversion, resultConversion, resultKind, originalUserDefinedOperatorsOpt: default, type, hasErrors)
         {
         }
 
-        public BoundIncrementOperator Update(UnaryOperatorKind operatorKind, BoundExpression operand, MethodSymbol? methodOpt, Conversion operandConversion, Conversion resultConversion, LookupResultKind resultKind, TypeSymbol type)
+        public BoundIncrementOperator Update(UnaryOperatorKind operatorKind, BoundExpression operand, MethodSymbol? methodOpt, TypeSymbol? constrainedToTypeOpt, Conversion operandConversion, Conversion resultConversion, LookupResultKind resultKind, TypeSymbol type)
         {
-            return Update(operatorKind, operand, methodOpt, operandConversion, resultConversion, resultKind, this.OriginalUserDefinedOperatorsOpt, type);
+            return Update(operatorKind, operand, methodOpt, constrainedToTypeOpt, operandConversion, resultConversion, resultKind, this.OriginalUserDefinedOperatorsOpt, type);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/NullabilityRewriter.cs b/src/Compilers/CSharp/Portable/BoundTree/NullabilityRewriter.cs
index 784ebc8c7b4a0..e426680a1d18d 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/NullabilityRewriter.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/NullabilityRewriter.cs
@@ -54,9 +54,9 @@ private BoundNode VisitBinaryOperatorBase(BoundBinaryOperatorBase binaryOperator
 
                 currentBinary = currentBinary switch
                 {
-                    BoundBinaryOperator binary => binary.Update(binary.OperatorKind, binary.ConstantValueOpt, GetUpdatedSymbol(binary, binary.MethodOpt), binary.ResultKind, binary.OriginalUserDefinedOperatorsOpt, leftChild, right, type!),
+                    BoundBinaryOperator binary => binary.Update(binary.OperatorKind, binary.ConstantValueOpt, GetUpdatedSymbol(binary, binary.MethodOpt), binary.ConstrainedToTypeOpt, binary.ResultKind, binary.OriginalUserDefinedOperatorsOpt, leftChild, right, type!),
                     // https://github.com/dotnet/roslyn/issues/35031: We'll need to update logical.LogicalOperator
-                    BoundUserDefinedConditionalLogicalOperator logical => logical.Update(logical.OperatorKind, logical.LogicalOperator, logical.TrueOperator, logical.FalseOperator, logical.ResultKind, logical.OriginalUserDefinedOperatorsOpt, leftChild, right, type!),
+                    BoundUserDefinedConditionalLogicalOperator logical => logical.Update(logical.OperatorKind, logical.LogicalOperator, logical.TrueOperator, logical.FalseOperator, logical.ConstrainedToTypeOpt, logical.ResultKind, logical.OriginalUserDefinedOperatorsOpt, leftChild, right, type!),
                     _ => throw ExceptionUtilities.UnexpectedValue(currentBinary.Kind),
                 };
 
diff --git a/src/Compilers/CSharp/Portable/BoundTree/TupleBinaryOperatorInfo.cs b/src/Compilers/CSharp/Portable/BoundTree/TupleBinaryOperatorInfo.cs
index 6fc6b4ae32ed4..1def54d05dca6 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/TupleBinaryOperatorInfo.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/TupleBinaryOperatorInfo.cs
@@ -46,6 +46,7 @@ internal class Single : TupleBinaryOperatorInfo
         {
             internal readonly BinaryOperatorKind Kind;
             internal readonly MethodSymbol? MethodSymbolOpt; // User-defined comparison operator, if applicable
+            internal readonly TypeSymbol? ConstrainedToTypeOpt;
 
             internal readonly Conversion ConversionForBool; // If a conversion to bool exists, then no operator needed. If an operator is needed, this holds the conversion for input to that operator.
             internal readonly UnaryOperatorSignature BoolOperator; // Information for op_true or op_false
@@ -55,10 +56,12 @@ internal Single(
                 TypeSymbol? rightConvertedTypeOpt,
                 BinaryOperatorKind kind,
                 MethodSymbol? methodSymbolOpt,
+                TypeSymbol? constrainedToTypeOpt,
                 Conversion conversionForBool, UnaryOperatorSignature boolOperator) : base(leftConvertedTypeOpt, rightConvertedTypeOpt)
             {
                 Kind = kind;
                 MethodSymbolOpt = methodSymbolOpt;
+                ConstrainedToTypeOpt = constrainedToTypeOpt;
                 ConversionForBool = conversionForBool;
                 BoolOperator = boolOperator;
 
diff --git a/src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs b/src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs
index 7f03fb6cb86a0..6b2a7b7bcd5f1 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs
@@ -37,6 +37,7 @@ internal sealed partial class BoundLocalFunctionStatement : IBoundLambdaOrFuncti
     internal readonly struct InferredLambdaReturnType
     {
         internal readonly int NumExpressions;
+        internal readonly bool IsExplicitType;
         internal readonly bool HadExpressionlessReturn;
         internal readonly RefKind RefKind;
         internal readonly TypeWithAnnotations TypeWithAnnotations;
@@ -45,6 +46,7 @@ internal readonly struct InferredLambdaReturnType
 
         internal InferredLambdaReturnType(
             int numExpressions,
+            bool isExplicitType,
             bool hadExpressionlessReturn,
             RefKind refKind,
             TypeWithAnnotations typeWithAnnotations,
@@ -52,6 +54,7 @@ internal InferredLambdaReturnType(
             ImmutableArray<AssemblySymbol> dependencies)
         {
             NumExpressions = numExpressions;
+            IsExplicitType = isExplicitType;
             HadExpressionlessReturn = hadExpressionlessReturn;
             RefKind = refKind;
             TypeWithAnnotations = typeWithAnnotations;
@@ -64,7 +67,7 @@ internal sealed partial class BoundLambda : IBoundLambdaOrFunction
     {
         public MessageID MessageID { get { return Syntax.Kind() == SyntaxKind.AnonymousMethodExpression ? MessageID.IDS_AnonMethod : MessageID.IDS_Lambda; } }
 
-        internal InferredLambdaReturnType InferredReturnType { get; private set; }
+        internal InferredLambdaReturnType InferredReturnType { get; }
 
         MethodSymbol IBoundLambdaOrFunction.Symbol { get { return Symbol; } }
 
@@ -105,12 +108,13 @@ public TypeWithAnnotations GetInferredReturnType(ConversionsBase? conversions, N
                 useSiteInfo.AddDependencies(InferredReturnType.Dependencies);
             }
 
-            if (nullableState == null)
+            if (nullableState == null || InferredReturnType.IsExplicitType)
             {
                 return InferredReturnType.TypeWithAnnotations;
             }
             else
             {
+                Debug.Assert(!UnboundLambda.HasExplicitReturnType(out _, out _));
                 Debug.Assert(conversions != null);
                 // Diagnostics from NullableWalker.Analyze can be dropped here since Analyze
                 // will be called again from NullableWalker.ApplyConversion when the
@@ -159,12 +163,14 @@ internal LambdaSymbol CreateLambdaSymbol(
         internal static InferredLambdaReturnType InferReturnType(ArrayBuilder<(BoundReturnStatement, TypeWithAnnotations)> returnTypes,
             BoundLambda node, Binder binder, TypeSymbol? delegateType, bool isAsync, ConversionsBase conversions)
         {
+            Debug.Assert(!node.UnboundLambda.HasExplicitReturnType(out _, out _));
             return InferReturnTypeImpl(returnTypes, node, binder, delegateType, isAsync, conversions, node.UnboundLambda.WithDependencies);
         }
 
         internal static InferredLambdaReturnType InferReturnType(ArrayBuilder<(BoundReturnStatement, TypeWithAnnotations)> returnTypes,
             UnboundLambda node, Binder binder, TypeSymbol? delegateType, bool isAsync, ConversionsBase conversions)
         {
+            Debug.Assert(!node.HasExplicitReturnType(out _, out _));
             return InferReturnTypeImpl(returnTypes, node, binder, delegateType, isAsync, conversions, node.WithDependencies);
         }
 
@@ -199,9 +205,12 @@ private static InferredLambdaReturnType InferReturnTypeImpl(ArrayBuilder<(BoundR
             var bestType = CalculateReturnType(binder, conversions, delegateType, types, isAsync, node, ref useSiteInfo);
             int numExpressions = types.Count;
             types.Free();
-            return new InferredLambdaReturnType(numExpressions, hasReturnWithoutArgument, refKind, bestType,
-                                                useSiteInfo.Diagnostics.AsImmutableOrEmpty(),
-                                                useSiteInfo.AccumulatesDependencies ? useSiteInfo.Dependencies.AsImmutableOrEmpty() : ImmutableArray<AssemblySymbol>.Empty);
+            return new InferredLambdaReturnType(
+                numExpressions,
+                isExplicitType: false,
+                hasReturnWithoutArgument, refKind, bestType,
+                useSiteInfo.Diagnostics.AsImmutableOrEmpty(),
+                useSiteInfo.AccumulatesDependencies ? useSiteInfo.Dependencies.AsImmutableOrEmpty() : ImmutableArray<AssemblySymbol>.Empty);
         }
 
         private static TypeWithAnnotations CalculateReturnType(
@@ -342,14 +351,16 @@ public UnboundLambda(
             CSharpSyntaxNode syntax,
             Binder binder,
             bool withDependencies,
-            ImmutableArray<SyntaxList<AttributeListSyntax>> attributes,
+            RefKind returnRefKind,
+            TypeWithAnnotations returnType,
+            ImmutableArray<SyntaxList<AttributeListSyntax>> parameterAttributes,
             ImmutableArray<RefKind> refKinds,
             ImmutableArray<TypeWithAnnotations> types,
             ImmutableArray<string> names,
             ImmutableArray<bool> discardsOpt,
             bool isAsync,
             bool isStatic)
-            : this(syntax, new PlainUnboundLambdaState(binder, attributes, names, discardsOpt, types, refKinds, isAsync, isStatic, includeCache: true), withDependencies, !types.IsDefault && types.Any(t => t.Type?.Kind == SymbolKind.ErrorType))
+            : this(syntax, new PlainUnboundLambdaState(binder, returnRefKind, returnType, parameterAttributes, names, discardsOpt, types, refKinds, isAsync, isStatic, includeCache: true), withDependencies, !types.IsDefault && types.Any(t => t.Type?.Kind == SymbolKind.ErrorType))
         {
             Debug.Assert(binder != null);
             Debug.Assert(syntax.IsAnonymousFunction());
@@ -401,6 +412,8 @@ private BoundLambda SuppressIfNeeded(BoundLambda lambda)
             => this.IsSuppressed ? (BoundLambda)lambda.WithSuppression() : lambda;
 
         public bool HasSignature { get { return Data.HasSignature; } }
+        public bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType)
+            => Data.HasExplicitReturnType(out refKind, out returnType);
         public bool HasExplicitlyTypedParameterList { get { return Data.HasExplicitlyTypedParameterList; } }
         public int ParameterCount { get { return Data.ParameterCount; } }
         public TypeWithAnnotations InferReturnType(ConversionsBase conversions, NamedTypeSymbol delegateType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
@@ -478,6 +491,7 @@ internal UnboundLambdaState WithCaching(bool includeCache)
         public abstract bool ParameterIsDiscard(int index);
         public abstract SyntaxList<AttributeListSyntax> ParameterAttributes(int index);
         public abstract bool HasSignature { get; }
+        public abstract bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType);
         public abstract bool HasExplicitlyTypedParameterList { get; }
         public abstract int ParameterCount { get; }
         public abstract bool IsAsync { get; }
@@ -556,68 +570,63 @@ private static TypeWithAnnotations DelegateReturnTypeWithAnnotations(MethodSymbo
             return invokeMethod.ReturnTypeWithAnnotations;
         }
 
-        private bool DelegateNeedsReturn(MethodSymbol? invokeMethod)
+        internal NamedTypeSymbol? InferDelegateType(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
-            if (invokeMethod is null || invokeMethod.ReturnsVoid)
-            {
-                return false;
-            }
+            Debug.Assert(Binder.ContainingMemberOrLambda is { });
 
-            if (IsAsync && invokeMethod.ReturnType.IsNonGenericTaskType(this.Binder.Compilation))
+            if (!HasExplicitlyTypedParameterList)
             {
-                return false;
+                return null;
             }
 
-            return true;
-        }
-
-        internal NamedTypeSymbol? InferDelegateType(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
-        {
-            Debug.Assert(Binder.ContainingMemberOrLambda is { });
-
-            var compilation = Binder.Compilation;
             var parameterRefKindsBuilder = ArrayBuilder<RefKind>.GetInstance(ParameterCount);
             var parameterTypesBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(ParameterCount);
             for (int i = 0; i < ParameterCount; i++)
             {
-                parameterRefKindsBuilder.Add(HasExplicitlyTypedParameterList ? RefKind(i) : default);
-                parameterTypesBuilder.Add(HasExplicitlyTypedParameterList ? ParameterTypeWithAnnotations(i) : TypeWithAnnotations.Create(compilation.GetSpecialType(SpecialType.System_Object)));
+                parameterRefKindsBuilder.Add(RefKind(i));
+                parameterTypesBuilder.Add(ParameterTypeWithAnnotations(i));
             }
             var parameterRefKinds = parameterRefKindsBuilder.ToImmutableAndFree();
             var parameterTypes = parameterTypesBuilder.ToImmutableAndFree();
 
-            var lambdaSymbol = new LambdaSymbol(
-                Binder,
-                compilation,
-                Binder.ContainingMemberOrLambda,
-                _unboundLambda,
-                parameterTypes,
-                parameterRefKinds,
-                refKind: default,
-                returnType: default);
-            var lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, ParameterBinder(lambdaSymbol, Binder));
-            var block = BindLambdaBody(lambdaSymbol, lambdaBodyBinder, BindingDiagnosticBag.Discarded);
-            var returnTypes = ArrayBuilder<(BoundReturnStatement, TypeWithAnnotations)>.GetInstance();
-            BoundLambda.BlockReturns.GetReturnTypes(returnTypes, block);
-            var inferredReturnType = BoundLambda.InferReturnType(
-                returnTypes,
-                _unboundLambda,
-                lambdaBodyBinder,
-                delegateType: null,
-                isAsync: IsAsync,
-                Binder.Conversions);
-
-            if (HasExplicitlyTypedParameterList && (inferredReturnType.TypeWithAnnotations.HasType || returnTypes.Count == 0))
+            if (!HasExplicitReturnType(out var returnRefKind, out var returnType))
             {
-                return Binder.GetMethodGroupOrLambdaDelegateType(
-                    inferredReturnType.RefKind,
-                    inferredReturnType.TypeWithAnnotations,
-                    parameterRefKinds,
+                var lambdaSymbol = new LambdaSymbol(
+                    Binder,
+                    Binder.Compilation,
+                    Binder.ContainingMemberOrLambda,
+                    _unboundLambda,
                     parameterTypes,
-                    ref useSiteInfo);
+                    parameterRefKinds,
+                    refKind: default,
+                    returnType: default);
+                var lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, ParameterBinder(lambdaSymbol, Binder));
+                var block = BindLambdaBody(lambdaSymbol, lambdaBodyBinder, BindingDiagnosticBag.Discarded);
+                var returnTypes = ArrayBuilder<(BoundReturnStatement, TypeWithAnnotations)>.GetInstance();
+                BoundLambda.BlockReturns.GetReturnTypes(returnTypes, block);
+                var inferredReturnType = BoundLambda.InferReturnType(
+                    returnTypes,
+                    _unboundLambda,
+                    lambdaBodyBinder,
+                    delegateType: null,
+                    isAsync: IsAsync,
+                    Binder.Conversions);
+
+                returnType = inferredReturnType.TypeWithAnnotations;
+                returnRefKind = inferredReturnType.RefKind;
+
+                if (!returnType.HasType && returnTypes.Count > 0)
+                {
+                    return null;
+                }
             }
 
-            return null;
+            return Binder.GetMethodGroupOrLambdaDelegateType(
+                returnRefKind,
+                returnType.Type?.IsVoidType() == true ? default : returnType,
+                parameterRefKinds,
+                parameterTypes,
+                ref useSiteInfo);
         }
 
         private BoundLambda ReallyBind(NamedTypeSymbol delegateType)
@@ -692,7 +701,7 @@ private BoundLambda ReallyBind(NamedTypeSymbol delegateType)
             bool reachableEndpoint = ControlFlowPass.Analyze(compilation, lambdaSymbol, block, diagnostics.DiagnosticBag);
             if (reachableEndpoint)
             {
-                if (DelegateNeedsReturn(invokeMethod))
+                if (Binder.MethodOrLambdaRequiresValue(lambdaSymbol, this.Binder.Compilation))
                 {
                     // Not all code paths return a value in {0} of type '{1}'
                     diagnostics.Add(ErrorCode.ERR_AnonymousReturnExpected, lambdaSymbol.DiagnosticLocation, this.MessageID.Localize(), delegateType);
@@ -707,20 +716,14 @@ private BoundLambda ReallyBind(NamedTypeSymbol delegateType)
             {
                 if (returnType.HasType && // Can be null if "delegateType" is not actually a delegate type.
                     !returnType.IsVoidType() &&
-                    !returnType.Type.IsNonGenericTaskType(compilation) &&
-                    !returnType.Type.IsGenericTaskType(compilation))
+                    !lambdaSymbol.IsAsyncEffectivelyReturningTask(compilation) &&
+                    !lambdaSymbol.IsAsyncEffectivelyReturningGenericTask(compilation))
                 {
                     // Cannot convert async {0} to delegate type '{1}'. An async {0} may return void, Task or Task&lt;T&gt;, none of which are convertible to '{1}'.
                     diagnostics.Add(ErrorCode.ERR_CantConvAsyncAnonFuncReturns, lambdaSymbol.DiagnosticLocation, lambdaSymbol.MessageID.Localize(), delegateType);
                 }
             }
 
-            if (IsAsync)
-            {
-                Debug.Assert(lambdaSymbol.IsAsync);
-                lambdaSymbol.ReportAsyncParameterErrors(diagnostics, lambdaSymbol.DiagnosticLocation);
-            }
-
             var result = new BoundLambda(_unboundLambda.Syntax, _unboundLambda, block, diagnostics.ToReadOnlyAndFree(), lambdaBodyBinder, delegateType, inferredReturnType: default)
             { WasCompilerGenerated = _unboundLambda.WasCompilerGenerated };
 
@@ -747,8 +750,8 @@ internal LambdaSymbol CreateLambdaSymbol(NamedTypeSymbol delegateType, Symbol co
         {
             var invokeMethod = DelegateInvokeMethod(delegateType);
             var returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out RefKind refKind);
-            var cacheKey = ReturnInferenceCacheKey.Create(delegateType, IsAsync);
-            return CreateLambdaSymbol(containingSymbol, returnType, cacheKey.ParameterTypes, cacheKey.ParameterRefKinds, refKind);
+            ReturnInferenceCacheKey.GetFields(delegateType, IsAsync, out var parameterTypes, out var parameterRefKinds, out _);
+            return CreateLambdaSymbol(containingSymbol, returnType, parameterTypes, parameterRefKinds, refKind);
         }
 
         private void ValidateUnsafeParameters(BindingDiagnosticBag diagnostics, ImmutableArray<TypeWithAnnotations> targetParameterTypes)
@@ -781,10 +784,40 @@ private BoundLambda ReallyInferReturnType(
             ImmutableArray<TypeWithAnnotations> parameterTypes,
             ImmutableArray<RefKind> parameterRefKinds)
         {
-            (var lambdaSymbol, var block, var lambdaBodyBinder, var diagnostics) = BindWithParameterAndReturnType(parameterTypes, parameterRefKinds, returnType: default, refKind: CodeAnalysis.RefKind.None);
-            var returnTypes = ArrayBuilder<(BoundReturnStatement, TypeWithAnnotations)>.GetInstance();
-            BoundLambda.BlockReturns.GetReturnTypes(returnTypes, block);
-            var inferredReturnType = BoundLambda.InferReturnType(returnTypes, _unboundLambda, lambdaBodyBinder, delegateType, lambdaSymbol.IsAsync, lambdaBodyBinder.Conversions);
+            bool hasExplicitReturnType = HasExplicitReturnType(out var refKind, out var returnType);
+            (var lambdaSymbol, var block, var lambdaBodyBinder, var diagnostics) = BindWithParameterAndReturnType(parameterTypes, parameterRefKinds, returnType, refKind);
+            InferredLambdaReturnType inferredReturnType;
+            if (hasExplicitReturnType)
+            {
+                // The InferredLambdaReturnType fields other than RefKind and ReturnType
+                // are only used when actually inferring a type, not when the type is explicit.
+                inferredReturnType = new InferredLambdaReturnType(
+                    numExpressions: 0,
+                    isExplicitType: true,
+                    hadExpressionlessReturn: false,
+                    refKind,
+                    returnType,
+                    ImmutableArray<DiagnosticInfo>.Empty,
+                    ImmutableArray<AssemblySymbol>.Empty);
+            }
+            else
+            {
+                var returnTypes = ArrayBuilder<(BoundReturnStatement, TypeWithAnnotations)>.GetInstance();
+                BoundLambda.BlockReturns.GetReturnTypes(returnTypes, block);
+                inferredReturnType = BoundLambda.InferReturnType(returnTypes, _unboundLambda, lambdaBodyBinder, delegateType, lambdaSymbol.IsAsync, lambdaBodyBinder.Conversions);
+                // TODO: Should InferredReturnType.UseSiteDiagnostics be merged into BoundLambda.Diagnostics?
+                refKind = inferredReturnType.RefKind;
+                returnType = inferredReturnType.TypeWithAnnotations;
+                if (!returnType.HasType)
+                {
+                    bool forErrorRecovery = delegateType is null;
+                    returnType = (forErrorRecovery && returnTypes.Count == 0)
+                        ? TypeWithAnnotations.Create(this.Binder.Compilation.GetSpecialType(SpecialType.System_Void))
+                        : TypeWithAnnotations.Create(LambdaSymbol.InferenceFailureReturnType);
+                }
+                returnTypes.Free();
+            }
+
             var result = new BoundLambda(
                 _unboundLambda.Syntax,
                 _unboundLambda,
@@ -795,18 +828,11 @@ private BoundLambda ReallyInferReturnType(
                 inferredReturnType)
             { WasCompilerGenerated = _unboundLambda.WasCompilerGenerated };
 
-            // TODO: Should InferredReturnType.UseSiteDiagnostics be merged into BoundLambda.Diagnostics?
-            var returnType = inferredReturnType.TypeWithAnnotations;
-            if (!returnType.HasType)
+            if (!hasExplicitReturnType)
             {
-                bool forErrorRecovery = delegateType is null;
-                returnType = (forErrorRecovery && returnTypes.Count == 0)
-                    ? TypeWithAnnotations.Create(this.Binder.Compilation.GetSpecialType(SpecialType.System_Void))
-                    : TypeWithAnnotations.Create(LambdaSymbol.InferenceFailureReturnType);
+                lambdaSymbol.SetInferredReturnType(refKind, returnType);
             }
 
-            lambdaSymbol.SetInferredReturnType(inferredReturnType.RefKind, returnType);
-            returnTypes.Free();
             return result;
         }
 
@@ -824,6 +850,7 @@ private BoundLambda ReallyInferReturnType(
                                                   refKind);
             var lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, ParameterBinder(lambdaSymbol, Binder));
             var block = BindLambdaBody(lambdaSymbol, lambdaBodyBinder, diagnostics);
+            lambdaSymbol.GetDeclarationDiagnostics(diagnostics);
             return (lambdaSymbol, block, lambdaBodyBinder, diagnostics);
         }
 
@@ -900,12 +927,27 @@ public override int GetHashCode()
             }
 
             public static ReturnInferenceCacheKey Create(NamedTypeSymbol? delegateType, bool isAsync)
+            {
+                GetFields(delegateType, isAsync, out var parameterTypes, out var parameterRefKinds, out var taskLikeReturnTypeOpt);
+                if (parameterTypes.IsEmpty && parameterRefKinds.IsEmpty && taskLikeReturnTypeOpt is null)
+                {
+                    return Empty;
+                }
+                return new ReturnInferenceCacheKey(parameterTypes, parameterRefKinds, taskLikeReturnTypeOpt);
+            }
+
+            public static void GetFields(
+                NamedTypeSymbol? delegateType,
+                bool isAsync,
+                out ImmutableArray<TypeWithAnnotations> parameterTypes,
+                out ImmutableArray<RefKind> parameterRefKinds,
+                out NamedTypeSymbol? taskLikeReturnTypeOpt)
             {
                 // delegateType or DelegateInvokeMethod can be null in cases of malformed delegates
                 // in such case we would want something trivial with no parameters
-                var parameterTypes = ImmutableArray<TypeWithAnnotations>.Empty;
-                var parameterRefKinds = ImmutableArray<RefKind>.Empty;
-                NamedTypeSymbol? taskLikeReturnTypeOpt = null;
+                parameterTypes = ImmutableArray<TypeWithAnnotations>.Empty;
+                parameterRefKinds = ImmutableArray<RefKind>.Empty;
+                taskLikeReturnTypeOpt = null;
                 MethodSymbol? invoke = DelegateInvokeMethod(delegateType);
                 if (invoke is not null)
                 {
@@ -937,13 +979,6 @@ public static ReturnInferenceCacheKey Create(NamedTypeSymbol? delegateType, bool
                         }
                     }
                 }
-
-                if (parameterTypes.IsEmpty && parameterRefKinds.IsEmpty && taskLikeReturnTypeOpt is null)
-                {
-                    return Empty;
-                }
-
-                return new ReturnInferenceCacheKey(parameterTypes, parameterRefKinds, taskLikeReturnTypeOpt);
             }
         }
 
@@ -996,7 +1031,7 @@ private BoundLambda ReallyBindForErrorRecovery()
             return
                 GuessBestBoundLambda(_bindingCache!)
                 ?? rebind(GuessBestBoundLambda(_returnInferenceCache!))
-                ?? rebind(ReallyInferReturnType(null, ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty));
+                ?? rebind(ReallyInferReturnType(delegateType: null, ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty));
 
             // Rebind a lambda to push target conversions through the return/result expressions
             [return: NotNullIfNotNull("lambda")] BoundLambda? rebind(BoundLambda? lambda)
@@ -1004,8 +1039,8 @@ private BoundLambda ReallyBindForErrorRecovery()
                 if (lambda is null)
                     return null;
                 var delegateType = (NamedTypeSymbol?)lambda.Type;
-                var cacheKey = ReturnInferenceCacheKey.Create(delegateType, IsAsync);
-                return ReallyBindForErrorRecovery(delegateType, lambda.InferredReturnType, cacheKey.ParameterTypes, cacheKey.ParameterRefKinds);
+                ReturnInferenceCacheKey.GetFields(delegateType, IsAsync, out var parameterTypes, out var parameterRefKinds, out _);
+                return ReallyBindForErrorRecovery(delegateType, lambda.InferredReturnType, parameterTypes, parameterRefKinds);
             }
         }
 
@@ -1019,6 +1054,7 @@ private BoundLambda ReallyBindForErrorRecovery(
             var refKind = inferredReturnType.RefKind;
             if (!returnType.HasType)
             {
+                Debug.Assert(!inferredReturnType.IsExplicitType);
                 var invokeMethod = DelegateInvokeMethod(delegateType);
                 returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out refKind);
                 if (!returnType.HasType || returnType.Type.ContainsTypeParameter())
@@ -1039,7 +1075,7 @@ private BoundLambda ReallyBindForErrorRecovery(
                 diagnostics.ToReadOnlyAndFree(),
                 lambdaBodyBinder,
                 delegateType,
-                new InferredLambdaReturnType(inferredReturnType.NumExpressions, inferredReturnType.HadExpressionlessReturn, refKind, returnType, ImmutableArray<DiagnosticInfo>.Empty, ImmutableArray<AssemblySymbol>.Empty))
+                new InferredLambdaReturnType(inferredReturnType.NumExpressions, isExplicitType: inferredReturnType.IsExplicitType, inferredReturnType.HadExpressionlessReturn, refKind, returnType, ImmutableArray<DiagnosticInfo>.Empty, ImmutableArray<AssemblySymbol>.Empty))
             { WasCompilerGenerated = _unboundLambda.WasCompilerGenerated };
         }
 
@@ -1221,6 +1257,8 @@ private static int CanonicallyCompareDiagnostics(Diagnostic x, Diagnostic y)
 
     internal sealed class PlainUnboundLambdaState : UnboundLambdaState
     {
+        private readonly RefKind _returnRefKind;
+        private readonly TypeWithAnnotations _returnType;
         private readonly ImmutableArray<SyntaxList<AttributeListSyntax>> _parameterAttributes;
         private readonly ImmutableArray<string> _parameterNames;
         private readonly ImmutableArray<bool> _parameterIsDiscardOpt;
@@ -1231,6 +1269,8 @@ internal sealed class PlainUnboundLambdaState : UnboundLambdaState
 
         internal PlainUnboundLambdaState(
             Binder binder,
+            RefKind returnRefKind,
+            TypeWithAnnotations returnType,
             ImmutableArray<SyntaxList<AttributeListSyntax>> parameterAttributes,
             ImmutableArray<string> parameterNames,
             ImmutableArray<bool> parameterIsDiscardOpt,
@@ -1241,6 +1281,8 @@ internal PlainUnboundLambdaState(
             bool includeCache)
             : base(binder, includeCache)
         {
+            _returnRefKind = returnRefKind;
+            _returnType = returnType;
             _parameterAttributes = parameterAttributes;
             _parameterNames = parameterNames;
             _parameterIsDiscardOpt = parameterIsDiscardOpt;
@@ -1254,6 +1296,13 @@ internal PlainUnboundLambdaState(
 
         public override bool HasSignature { get { return !_parameterNames.IsDefault; } }
 
+        public override bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType)
+        {
+            refKind = _returnRefKind;
+            returnType = _returnType;
+            return _returnType.HasType;
+        }
+
         public override bool HasExplicitlyTypedParameterList { get { return !_parameterTypesWithAnnotations.IsDefault; } }
 
         public override int ParameterCount { get { return _parameterNames.IsDefault ? 0 : _parameterNames.Length; } }
@@ -1321,7 +1370,7 @@ public override TypeWithAnnotations ParameterTypeWithAnnotations(int index)
 
         protected override UnboundLambdaState WithCachingCore(bool includeCache)
         {
-            return new PlainUnboundLambdaState(Binder, _parameterAttributes, _parameterNames, _parameterIsDiscardOpt, _parameterTypesWithAnnotations, _parameterRefKinds, _isAsync, _isStatic, includeCache);
+            return new PlainUnboundLambdaState(Binder, _returnRefKind, _returnType, _parameterAttributes, _parameterNames, _parameterIsDiscardOpt, _parameterTypesWithAnnotations, _parameterRefKinds, _isAsync, _isStatic, includeCache);
         }
 
         protected override BoundExpression? GetLambdaExpressionBody(BoundBlock body)
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index 7d985cbbd1a80..8f869b9268be6 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -667,7 +667,7 @@
     <value>Type '{1}' already defines a member called '{0}' with the same parameter types</value>
   </data>
   <data name="ERR_StaticNotVirtual" xml:space="preserve">
-    <value>A static member '{0}' cannot be marked as override, virtual, or abstract</value>
+    <value>A static member cannot be marked as '{0}'</value>
   </data>
   <data name="ERR_OverrideNotNew" xml:space="preserve">
     <value>A member '{0}' marked as override cannot be marked as new or virtual</value>
@@ -1665,7 +1665,7 @@ If such a class is used as a base class and if the deriving class defines a dest
     <value>'{0}': user-defined conversions to or from a derived type are not allowed</value>
   </data>
   <data name="ERR_IdentityConversion" xml:space="preserve">
-    <value>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</value>
+    <value>User-defined operator cannot convert a type to itself</value>
   </data>
   <data name="ERR_ConversionNotInvolvingContainedType" xml:space="preserve">
     <value>User-defined conversion must convert to or from the enclosing type</value>
@@ -1689,7 +1689,7 @@ If such a class is used as a base class and if the deriving class defines a dest
     <value>The first operand of an overloaded shift operator must have the same type as the containing type, and the type of the second operand must be int</value>
   </data>
   <data name="ERR_InterfacesCantContainConversionOrEqualityOperators" xml:space="preserve">
-    <value>Interfaces cannot contain conversion, equality, or inequality operators</value>
+    <value>Conversion, equality, or inequality operators declared in interfaces must be abstract</value>
   </data>
   <data name="ERR_StructsCantContainDefaultConstructor" xml:space="preserve">
     <value>Structs cannot contain explicit parameterless constructors</value>
@@ -2151,7 +2151,7 @@ If such a class is used as a base class and if the deriving class defines a dest
     <value>Invalid type specified as an argument for TypeForwardedTo attribute</value>
   </data>
   <data name="ERR_CloseUnimplementedInterfaceMemberStatic" xml:space="preserve">
-    <value>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</value>
+    <value>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</value>
   </data>
   <data name="ERR_CloseUnimplementedInterfaceMemberNotPublic" xml:space="preserve">
     <value>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is not public.</value>
@@ -3019,6 +3019,9 @@ A catch() block after a catch (System.Exception e) block can catch non-CLS excep
   <data name="ERR_CantConvAnonMethParams" xml:space="preserve">
     <value>Cannot convert {0} to type '{1}' because the parameter types do not match the delegate parameter types</value>
   </data>
+  <data name="ERR_CantConvAnonMethReturnType" xml:space="preserve">
+    <value>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</value>
+  </data>
   <data name="ERR_CantConvAnonMethReturns" xml:space="preserve">
     <value>Cannot convert {0} to intended delegate type because some of the return types in the block are not implicitly convertible to the delegate return type</value>
   </data>
@@ -3740,6 +3743,9 @@ Give the compiler some way to differentiate the methods. For example, you can gi
   <data name="ERR_BadAsyncReturn" xml:space="preserve">
     <value>The return type of an async method must be void, Task, Task&lt;T&gt;, a task-like type, IAsyncEnumerable&lt;T&gt;, or IAsyncEnumerator&lt;T&gt;</value>
   </data>
+  <data name="ERR_WrongArityAsyncReturn" xml:space="preserve">
+    <value>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</value>
+  </data>
   <data name="ERR_CantReturnVoid" xml:space="preserve">
     <value>Cannot return an expression of type 'void'</value>
   </data>
@@ -4172,9 +4178,6 @@ You should consider suppressing the warning only if you're sure that you don't w
   <data name="ERR_DeprecatedCollectionInitAddStr" xml:space="preserve">
     <value>The best overloaded Add method '{0}' for the collection initializer element is obsolete. {1}</value>
   </data>
-  <data name="ERR_IteratorInInteractive" xml:space="preserve">
-    <value>Yield statements may not appear at the top level in interactive code.</value>
-  </data>
   <data name="ERR_SecurityAttributeInvalidTarget" xml:space="preserve">
     <value>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</value>
   </data>
@@ -5317,9 +5320,6 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_BadAsyncMethodBuilderTaskProperty" xml:space="preserve">
     <value>For type '{0}' to be used as an AsyncMethodBuilder for type '{1}', its Task property should return type '{1}' instead of type '{2}'.</value>
   </data>
-  <data name="ERR_AttributesInLocalFuncDecl" xml:space="preserve">
-    <value>Attributes are not allowed on local function parameters or type parameters</value>
-  </data>
   <data name="ERR_TypeForwardedToMultipleAssemblies" xml:space="preserve">
     <value>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</value>
   </data>
@@ -6074,7 +6074,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
     <value>The modifier '{0}' is not valid for this item in C# {1}. Please use language version '{2}' or greater.</value>
   </data>
   <data name="ERR_ImplicitImplementationOfNonPublicInterfaceMember" xml:space="preserve">
-    <value>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</value>
+    <value>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</value>
   </data>
   <data name="ERR_MostSpecificImplementationIsNotFound" xml:space="preserve">
     <value>Interface member '{0}' does not have a most specific implementation. Neither '{1}', nor '{2}' are most specific.</value>
@@ -6415,6 +6415,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_FeatureNotAvailableInVersion9" xml:space="preserve">
     <value>Feature '{0}' is not available in C# 9.0. Please use language version {1} or greater.</value>
   </data>
+  <data name="ERR_FeatureNotAvailableInVersion10" xml:space="preserve">
+    <value>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</value>
+  </data>
   <data name="ERR_UnexpectedArgumentList" xml:space="preserve">
     <value>Unexpected argument list.</value>
   </data>
@@ -6527,7 +6530,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
     <value>extension GetEnumerator</value>
   </data>
   <data name="ERR_UnmanagedCallersOnlyRequiresStatic" xml:space="preserve">
-    <value>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</value>
+    <value>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</value>
     <comment>UnmanagedCallersOnly is not localizable.</comment>
   </data>
   <data name="ERR_InvalidUnmanagedCallersOnlyCallConv" xml:space="preserve">
@@ -6585,6 +6588,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="IDS_FeatureWithOnAnonymousTypes" xml:space="preserve">
     <value>with on anonymous types</value>
   </data>
+  <data name="IDS_AsyncMethodBuilderOverride" xml:space="preserve">
+    <value>async method builder override</value>
+  </data>
   <data name="IDS_FeaturePositionalFieldsInRecords" xml:space="preserve">
     <value>positional fields in records</value>
   </data>
@@ -6619,9 +6625,21 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="IDS_FeatureLambdaAttributes" xml:space="preserve">
     <value>lambda attributes</value>
   </data>
+  <data name="IDS_FeatureLambdaReturnType" xml:space="preserve">
+    <value>lambda return type</value>
+  </data>
   <data name="IDS_FeatureInferredDelegateType" xml:space="preserve">
     <value>inferred delegate type</value>
   </data>
+  <data name="IDS_FeatureLineSpanDirective" xml:space="preserve">
+    <value>line span directive</value>
+  </data>
+  <data name="ERR_LineSpanDirectiveInvalidValue" xml:space="preserve">
+    <value>The #line directive value is missing or out of range</value>
+  </data>
+  <data name="ERR_LineSpanDirectiveEndLessThanStart" xml:space="preserve">
+    <value>The #line directive end position must be greater than or equal to the start position</value>
+  </data>
   <data name="WRN_DoNotCompareFunctionPointers" xml:space="preserve">
     <value>Comparison of function pointers might yield an unexpected result, since pointers to the same function may be distinct.</value>
   </data>
@@ -6709,4 +6727,62 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_InterpolatedStringHandlerCreationCannotUseDynamic" xml:space="preserve">
     <value>An interpolated string handler construction cannot use dynamic. Manually construct an instance of '{0}'.</value>
   </data>
+  <data name="IDS_FeatureStaticAbstractMembersInInterfaces" xml:space="preserve">
+    <value>static abstract members in interfaces</value>
+  </data>
+  <data name="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces" xml:space="preserve">
+    <value>Target runtime doesn't support static abstract members in interfaces.</value>
+  </data>
+  <data name="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers" xml:space="preserve">
+    <value>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</value>
+  </data>
+  <data name="ERR_BadAbstractUnaryOperatorSignature" xml:space="preserve">
+    <value>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</value>
+  </data>
+  <data name="ERR_BadAbstractIncDecSignature" xml:space="preserve">
+    <value>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</value>
+  </data>
+  <data name="ERR_BadAbstractIncDecRetType" xml:space="preserve">
+    <value>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</value>
+  </data>
+  <data name="ERR_BadAbstractBinaryOperatorSignature" xml:space="preserve">
+    <value>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</value>
+  </data>
+  <data name="ERR_BadAbstractShiftOperatorSignature" xml:space="preserve">
+    <value>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</value>
+  </data>
+  <data name="ERR_BadAbstractStaticMemberAccess" xml:space="preserve">
+    <value>A static abstract interface member can be accessed only on a type parameter.</value>
+  </data>
+  <data name="ERR_ExpressionTreeContainsAbstractStaticMemberAccess" xml:space="preserve">
+    <value>An expression tree may not contain an access of static abstract interface member</value>
+  </data>
+  <data name="ERR_CloseUnimplementedInterfaceMemberNotStatic" xml:space="preserve">
+    <value>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</value>
+  </data>
+  <data name="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember" xml:space="preserve">
+    <value>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</value>
+  </data>
+  <data name="ERR_ExplicitImplementationOfOperatorsMustBeStatic" xml:space="preserve">
+    <value>Explicit implementation of a user-defined operator '{0}' must be declared static</value>
+  </data>
+  <data name="ERR_AbstractConversionNotInvolvingContainedType" xml:space="preserve">
+    <value>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</value>
+  </data>
+  <data name="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod" xml:space="preserve">
+    <value>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</value>
+    <comment>UnmanagedCallersOnly is not localizable.</comment>
+  </data>
+  <data name="HDN_DuplicateWithGlobalUsing" xml:space="preserve">
+    <value>The using directive for '{0}' appeared previously as global using</value>
+  </data>
+  <data name="HDN_DuplicateWithGlobalUsing_Title" xml:space="preserve">
+    <value>The using directive appeared previously as global using</value>
+  </data>
+  <data name="ERR_BuilderAttributeDisallowed" xml:space="preserve">
+    <value>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</value>
+  </data>
+  <data name="ERR_SimpleProgramIsEmpty" xml:space="preserve">
+    <value>At least one top-level statement must be non-empty.</value>
+  </data>
 </root>
diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitConversion.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitConversion.cs
index db65e2870aa69..61309792dc959 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitConversion.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitConversion.cs
@@ -324,6 +324,17 @@ private void EmitDelegateCreation(BoundExpression node, BoundExpression receiver
             if (isStatic)
             {
                 _builder.EmitNullConstant();
+
+                if (method.IsAbstract)
+                {
+                    if (receiver is not BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } })
+                    {
+                        throw ExceptionUtilities.Unreachable;
+                    }
+
+                    _builder.EmitOpCode(ILOpCode.Constrained);
+                    EmitSymbolToken(receiver.Type, receiver.Syntax);
+                }
             }
             else
             {
@@ -339,7 +350,7 @@ private void EmitDelegateCreation(BoundExpression node, BoundExpression receiver
             // Metadata Spec (II.14.6):
             //   Delegates shall be declared sealed.
             //   The Invoke method shall be virtual.
-            if (method.IsMetadataVirtual() && !method.ContainingType.IsDelegateType() && !receiver.SuppressVirtualCalls)
+            if (!method.IsStatic && method.IsMetadataVirtual() && !method.ContainingType.IsDelegateType() && !receiver.SuppressVirtualCalls)
             {
                 // NOTE: method.IsMetadataVirtual -> receiver != null
                 _builder.EmitOpCode(ILOpCode.Dup);
diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
index 31cd1d3d870dd..a57d88fd832c5 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
@@ -8,6 +8,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Reflection.Metadata;
+using System.Runtime.CompilerServices;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Roslyn.Utilities;
@@ -1479,116 +1480,160 @@ private enum CallKind
         }
 
         private void EmitCallExpression(BoundCall call, UseKind useKind)
+        {
+            if (call.Method.IsDefaultValueTypeConstructor())
+            {
+                EmitDefaultValueTypeConstructorCallExpression(call);
+            }
+            else if (!call.Method.RequiresInstanceReceiver)
+            {
+                EmitStaticCallExpression(call, useKind);
+            }
+            else
+            {
+                EmitInstanceCallExpression(call, useKind);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void EmitDefaultValueTypeConstructorCallExpression(BoundCall call)
         {
             var method = call.Method;
             var receiver = call.ReceiverOpt;
-            LocalDefinition tempOpt = null;
 
             // Calls to the default struct constructor are emitted as initobj, rather than call.
             // NOTE: constructor invocations are represented as BoundObjectCreationExpressions,
             // rather than BoundCalls.  This is why we can be confident that if we see a call to a
             // constructor, it has this very specific form.
-            if (method.IsDefaultValueTypeConstructor())
-            {
-                Debug.Assert(method.IsImplicitlyDeclared);
-                Debug.Assert(TypeSymbol.Equals(method.ContainingType, receiver.Type, TypeCompareKind.ConsiderEverything2));
-                Debug.Assert(receiver.Kind == BoundKind.ThisReference);
+            Debug.Assert(method.IsImplicitlyDeclared);
+            Debug.Assert(TypeSymbol.Equals(method.ContainingType, receiver.Type, TypeCompareKind.ConsiderEverything2));
+            Debug.Assert(receiver.Kind == BoundKind.ThisReference);
 
-                tempOpt = EmitReceiverRef(receiver, AddressKind.Writeable);
-                _builder.EmitOpCode(ILOpCode.Initobj);    //  initobj  <MyStruct>
-                EmitSymbolToken(method.ContainingType, call.Syntax);
-                FreeOptTemp(tempOpt);
+            LocalDefinition tempOpt = EmitReceiverRef(receiver, AddressKind.Writeable);
+            _builder.EmitOpCode(ILOpCode.Initobj);    //  initobj  <MyStruct>
+            EmitSymbolToken(method.ContainingType, call.Syntax);
+            FreeOptTemp(tempOpt);
+        }
 
-                return;
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void EmitStaticCallExpression(BoundCall call, UseKind useKind)
+        {
+            var method = call.Method;
+            var receiver = call.ReceiverOpt;
+            var arguments = call.Arguments;
+
+            Debug.Assert(method.IsStatic);
+
+            EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt);
+            int stackBehavior = GetCallStackBehavior(method, arguments);
+
+            if (method.IsAbstract)
+            {
+                if (receiver is not BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } })
+                {
+                    throw ExceptionUtilities.Unreachable;
+                }
+
+                _builder.EmitOpCode(ILOpCode.Constrained);
+                EmitSymbolToken(receiver.Type, receiver.Syntax);
             }
 
+            _builder.EmitOpCode(ILOpCode.Call, stackBehavior);
+
+            EmitSymbolToken(method, call.Syntax,
+                            method.IsVararg ? (BoundArgListOperator)arguments[arguments.Length - 1] : null);
+
+            EmitCallCleanup(call.Syntax, useKind, method);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void EmitInstanceCallExpression(BoundCall call, UseKind useKind)
+        {
+            var method = call.Method;
+            var receiver = call.ReceiverOpt;
             var arguments = call.Arguments;
+            LocalDefinition tempOpt = null;
+
+            Debug.Assert(!method.IsStatic && method.RequiresInstanceReceiver);
 
             CallKind callKind;
 
-            if (!method.RequiresInstanceReceiver)
+            var receiverType = receiver.Type;
+
+            if (receiverType.IsVerifierReference())
             {
-                callKind = CallKind.Call;
+                EmitExpression(receiver, used: true);
+
+                // In some cases CanUseCallOnRefTypeReceiver returns true which means that 
+                // null check is unnecessary and we can use "call"
+                if (receiver.SuppressVirtualCalls ||
+                    (!method.IsMetadataVirtual() && CanUseCallOnRefTypeReceiver(receiver)))
+                {
+                    callKind = CallKind.Call;
+                }
+                else
+                {
+                    callKind = CallKind.CallVirt;
+                }
             }
-            else
+            else if (receiverType.IsVerifierValue())
             {
-                var receiverType = receiver.Type;
-
-                if (receiverType.IsVerifierReference())
+                NamedTypeSymbol methodContainingType = method.ContainingType;
+                if (methodContainingType.IsVerifierValue())
                 {
-                    EmitExpression(receiver, used: true);
-
-                    // In some cases CanUseCallOnRefTypeReceiver returns true which means that 
-                    // null check is unnecessary and we can use "call"
-                    if (receiver.SuppressVirtualCalls ||
-                        (!method.IsMetadataVirtual() && CanUseCallOnRefTypeReceiver(receiver)))
+                    // if method is defined in the struct itself it is assumed to be mutating, unless 
+                    // it is a member of a readonly struct and is not a constructor
+                    var receiverAddresskind = IsReadOnlyCall(method, methodContainingType) ?
+                                                                    AddressKind.ReadOnly :
+                                                                    AddressKind.Writeable;
+                    if (MayUseCallForStructMethod(method))
                     {
+                        // NOTE: this should be either a method which overrides some abstract method or 
+                        //       does not override anything (with few exceptions, see MayUseCallForStructMethod); 
+                        //       otherwise we should not use direct 'call' and must use constrained call;
+
+                        // calling a method defined in a value type
+                        Debug.Assert(TypeSymbol.Equals(receiverType, methodContainingType, TypeCompareKind.ObliviousNullableModifierMatchesAny));
+                        tempOpt = EmitReceiverRef(receiver, receiverAddresskind);
                         callKind = CallKind.Call;
                     }
                     else
                     {
-                        callKind = CallKind.CallVirt;
+                        tempOpt = EmitReceiverRef(receiver, receiverAddresskind);
+                        callKind = CallKind.ConstrainedCallVirt;
                     }
                 }
-                else if (receiverType.IsVerifierValue())
+                else
                 {
-                    NamedTypeSymbol methodContainingType = method.ContainingType;
-                    if (methodContainingType.IsVerifierValue())
+                    // calling a method defined in a base class.
+
+                    // When calling a method that is virtual in metadata on a struct receiver, 
+                    // we use a constrained virtual call. If possible, it will skip boxing.
+                    if (method.IsMetadataVirtual())
                     {
-                        // if method is defined in the struct itself it is assumed to be mutating, unless 
-                        // it is a member of a readonly struct and is not a constructor
-                        var receiverAddresskind = IsReadOnlyCall(method, methodContainingType) ?
-                                                                        AddressKind.ReadOnly :
-                                                                        AddressKind.Writeable;
-                        if (MayUseCallForStructMethod(method))
-                        {
-                            // NOTE: this should be either a method which overrides some abstract method or 
-                            //       does not override anything (with few exceptions, see MayUseCallForStructMethod); 
-                            //       otherwise we should not use direct 'call' and must use constrained call;
-
-                            // calling a method defined in a value type
-                            Debug.Assert(TypeSymbol.Equals(receiverType, methodContainingType, TypeCompareKind.ObliviousNullableModifierMatchesAny));
-                            tempOpt = EmitReceiverRef(receiver, receiverAddresskind);
-                            callKind = CallKind.Call;
-                        }
-                        else
-                        {
-                            tempOpt = EmitReceiverRef(receiver, receiverAddresskind);
-                            callKind = CallKind.ConstrainedCallVirt;
-                        }
+                        // NB: all methods that a struct could inherit from bases are non-mutating
+                        //     treat receiver as ReadOnly
+                        tempOpt = EmitReceiverRef(receiver, AddressKind.ReadOnly);
+                        callKind = CallKind.ConstrainedCallVirt;
                     }
                     else
                     {
-                        // calling a method defined in a base class.
-
-                        // When calling a method that is virtual in metadata on a struct receiver, 
-                        // we use a constrained virtual call. If possible, it will skip boxing.
-                        if (method.IsMetadataVirtual())
-                        {
-                            // NB: all methods that a struct could inherit from bases are non-mutating
-                            //     treat receiver as ReadOnly
-                            tempOpt = EmitReceiverRef(receiver, AddressKind.ReadOnly);
-                            callKind = CallKind.ConstrainedCallVirt;
-                        }
-                        else
-                        {
-                            EmitExpression(receiver, used: true);
-                            EmitBox(receiverType, receiver.Syntax);
-                            callKind = CallKind.Call;
-                        }
+                        EmitExpression(receiver, used: true);
+                        EmitBox(receiverType, receiver.Syntax);
+                        callKind = CallKind.Call;
                     }
                 }
-                else
-                {
-                    // receiver is generic and method must come from the base or an interface or a generic constraint
-                    // if the receiver is actually a value type it would need to be boxed.
-                    // let .constrained sort this out. 
-                    callKind = receiverType.IsReferenceType && !IsRef(receiver) ?
-                                CallKind.CallVirt :
-                                CallKind.ConstrainedCallVirt;
-
-                    tempOpt = EmitReceiverRef(receiver, callKind == CallKind.ConstrainedCallVirt ? AddressKind.Constrained : AddressKind.Writeable);
-                }
+            }
+            else
+            {
+                // receiver is generic and method must come from the base or an interface or a generic constraint
+                // if the receiver is actually a value type it would need to be boxed.
+                // let .constrained sort this out. 
+                callKind = receiverType.IsReferenceType && !IsRef(receiver) ?
+                            CallKind.CallVirt :
+                            CallKind.ConstrainedCallVirt;
+
+                tempOpt = EmitReceiverRef(receiver, callKind == CallKind.ConstrainedCallVirt ? AddressKind.Constrained : AddressKind.Writeable);
             }
 
             // When emitting a callvirt to a virtual method we always emit the method info of the
@@ -1640,7 +1685,7 @@ private void EmitCallExpression(BoundCall call, UseKind useKind)
             }
 
             EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt);
-            int stackBehavior = GetCallStackBehavior(call.Method, call.Arguments);
+            int stackBehavior = GetCallStackBehavior(method, arguments);
             switch (callKind)
             {
                 case CallKind.Call:
@@ -1659,7 +1704,7 @@ private void EmitCallExpression(BoundCall call, UseKind useKind)
             }
 
             EmitSymbolToken(actualMethodTargetedByTheCall, call.Syntax,
-                            actualMethodTargetedByTheCall.IsVararg ? (BoundArgListOperator)call.Arguments[call.Arguments.Length - 1] : null);
+                            actualMethodTargetedByTheCall.IsVararg ? (BoundArgListOperator)arguments[arguments.Length - 1] : null);
 
             EmitCallCleanup(call.Syntax, useKind, method);
 
@@ -1785,7 +1830,7 @@ internal static bool MayUseCallForStructMethod(MethodSymbol method)
         {
             Debug.Assert(method.ContainingType.IsVerifierValue(), "this is not a value type");
 
-            if (!method.IsMetadataVirtual())
+            if (!method.IsMetadataVirtual() || method.IsStatic)
             {
                 return true;
             }
@@ -3474,6 +3519,17 @@ private void EmitLoadFunction(BoundFunctionPointerLoad load, bool used)
 
             if (used)
             {
+                if (load.TargetMethod.IsAbstract && load.TargetMethod.IsStatic)
+                {
+                    if (load.ConstrainedToTypeOpt is not { TypeKind: TypeKind.TypeParameter })
+                    {
+                        throw ExceptionUtilities.Unreachable;
+                    }
+
+                    _builder.EmitOpCode(ILOpCode.Constrained);
+                    EmitSymbolToken(load.ConstrainedToTypeOpt, load.Syntax);
+                }
+
                 _builder.EmitOpCode(ILOpCode.Ldftn);
                 EmitSymbolToken(load.TargetMethod, load.Syntax, optArgList: null);
             }
diff --git a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
index a1876560a93c9..d7ced20883e10 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
@@ -1103,23 +1103,32 @@ private static bool IsIndirectOrInstanceFieldAssignment(BoundAssignmentOperator
         public override BoundNode VisitCall(BoundCall node)
         {
             var receiver = node.ReceiverOpt;
+            MethodSymbol method = node.Method;
 
             // matches or a bit stronger than EmitReceiverRef
             // if there are any doubts that receiver is a ref type, 
             // assume we will need an address (that will prevent scheduling of receiver).
-            if (node.Method.RequiresInstanceReceiver)
+            if (method.RequiresInstanceReceiver)
             {
                 receiver = VisitCallReceiver(receiver);
             }
             else
             {
-                // TODO: for some reason receiver could be not null even if method is static...
-                //       it seems wrong, ignore for now.
+                Debug.Assert(method.IsStatic);
+
                 _counter += 1;
-                receiver = null;
+
+                if (method.IsAbstract && receiver is BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } } typeExpression)
+                {
+                    receiver = typeExpression.Update(aliasOpt: null, boundContainingTypeOpt: null, boundDimensionsOpt: ImmutableArray<BoundExpression>.Empty,
+                        typeWithAnnotations: typeExpression.TypeWithAnnotations, type: this.VisitType(typeExpression.Type));
+                }
+                else
+                {
+                    receiver = null;
+                }
             }
 
-            MethodSymbol method = node.Method;
             var rewrittenArguments = VisitArguments(node.Arguments, method.Parameters, node.ArgumentRefKindsOpt);
 
             return node.Update(receiver, method, rewrittenArguments);
@@ -1425,7 +1434,7 @@ public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)
                 }
 
                 var type = this.VisitType(binary.Type);
-                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.MethodOpt, binary.ResultKind, left, right, type);
+                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.MethodOpt, binary.ConstrainedToTypeOpt, binary.ResultKind, left, right, type);
 
                 if (stack.Count == 0)
                 {
@@ -1459,7 +1468,7 @@ private BoundNode VisitBinaryOperatorSimple(BoundBinaryOperator node)
 
                 EnsureStackState(cookie);   // implicit label here
 
-                return node.Update(node.OperatorKind, node.ConstantValueOpt, node.MethodOpt, node.ResultKind, left, right, node.Type);
+                return node.Update(node.OperatorKind, node.ConstantValueOpt, node.MethodOpt, node.ConstrainedToTypeOpt, node.ResultKind, left, right, node.Type);
             }
 
             return base.VisitBinaryOperator(node);
@@ -1543,7 +1552,7 @@ public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
                 var origStack = StackDepth();
                 PushEvalStack(new BoundDefaultExpression(node.Syntax, node.Operand.Type), ExprContext.Value);
                 BoundExpression operand = (BoundExpression)this.Visit(node.Operand);
-                return node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, node.ResultKind, node.Type);
+                return node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, node.ConstrainedToTypeOpt, node.ResultKind, node.Type);
             }
             else
             {
@@ -1985,7 +1994,7 @@ public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)
                 binary = stack.Pop();
                 var right = (BoundExpression)this.Visit(binary.Right);
                 var type = this.VisitType(binary.Type);
-                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.MethodOpt, binary.ResultKind, left, right, type);
+                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.MethodOpt, binary.ConstrainedToTypeOpt, binary.ResultKind, left, right, type);
 
                 if (stack.Count == 0)
                 {
@@ -2083,6 +2092,36 @@ public override BoundNode VisitAssignmentOperator(BoundAssignmentOperator node)
             }
         }
 
+#nullable enable
+        public override BoundNode VisitCall(BoundCall node)
+        {
+            BoundExpression? receiverOpt = node.ReceiverOpt;
+
+            if (node.Method.RequiresInstanceReceiver)
+            {
+                receiverOpt = (BoundExpression?)this.Visit(receiverOpt);
+            }
+            else
+            {
+                _nodeCounter++;
+
+                if (receiverOpt is BoundTypeExpression { AliasOpt: null, BoundContainingTypeOpt: null, BoundDimensionsOpt: { IsEmpty: true }, Type: { TypeKind: TypeKind.TypeParameter } } typeExpression)
+                {
+                    receiverOpt = typeExpression.Update(aliasOpt: null, boundContainingTypeOpt: null, boundDimensionsOpt: ImmutableArray<BoundExpression>.Empty,
+                        typeWithAnnotations: typeExpression.TypeWithAnnotations, type: this.VisitType(typeExpression.Type));
+                }
+                else if (receiverOpt is not null)
+                {
+                    throw ExceptionUtilities.Unreachable;
+                }
+            }
+
+            ImmutableArray<BoundExpression> arguments = this.VisitList(node.Arguments);
+            TypeSymbol? type = this.VisitType(node.Type);
+            return node.Update(receiverOpt, node.Method, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.IsDelegateCall, node.Expanded, node.InvokedAsExtensionMethod, node.ArgsToParamsOpt, node.DefaultArguments, node.ResultKind, node.OriginalMethodsOpt, type);
+        }
+#nullable disable
+
         public override BoundNode VisitCatchBlock(BoundCatchBlock node)
         {
             var exceptionSource = node.ExceptionSourceOpt;
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index 8959add27efdf..d1e8610148feb 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -4333,7 +4333,7 @@ protected override bool ShouldCheckTypeForMembers(MergedTypeDeclaration current)
             {
                 foreach (SingleTypeDeclaration typeDecl in current.Declarations)
                 {
-                    if (typeDecl.MemberNames.Contains(_name))
+                    if (typeDecl.MemberNames.ContainsKey(_name))
                     {
                         return true;
                     }
diff --git a/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs b/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs
index 85c6f95ffd137..a106610962e31 100644
--- a/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs
@@ -899,7 +899,7 @@ public override AwaitExpressionInfo GetAwaitExpressionInfo(AwaitExpressionSyntax
                 throw new ArgumentException("node.Kind==" + node.Kind());
             }
 
-            var bound = GetUpperBoundNode(node);
+            var bound = GetLowerBoundNode(node);
             BoundAwaitableInfo awaitableInfo = (((bound as BoundExpressionStatement)?.Expression ?? bound) as BoundAwaitExpression)?.AwaitableInfo;
             if (awaitableInfo == null)
             {
diff --git a/src/Compilers/CSharp/Portable/Compilation/SyntaxTreeSemanticModel.cs b/src/Compilers/CSharp/Portable/Compilation/SyntaxTreeSemanticModel.cs
index 7592924da90f0..7177c2780e9dd 100644
--- a/src/Compilers/CSharp/Portable/Compilation/SyntaxTreeSemanticModel.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/SyntaxTreeSemanticModel.cs
@@ -1703,18 +1703,15 @@ private string GetDeclarationName(CSharpSyntaxNode declaration)
                     }
 
                 case SyntaxKind.OperatorDeclaration:
-                    var operatorDecl = (OperatorDeclarationSyntax)declaration;
-
-                    return OperatorFacts.OperatorNameFromDeclaration(operatorDecl);
-
-                case SyntaxKind.ConversionOperatorDeclaration:
-                    if (((ConversionOperatorDeclarationSyntax)declaration).ImplicitOrExplicitKeyword.Kind() == SyntaxKind.ExplicitKeyword)
                     {
-                        return WellKnownMemberNames.ExplicitConversionName;
+                        var operatorDecl = (OperatorDeclarationSyntax)declaration;
+                        return GetDeclarationName(declaration, operatorDecl.ExplicitInterfaceSpecifier, OperatorFacts.OperatorNameFromDeclaration(operatorDecl));
                     }
-                    else
+
+                case SyntaxKind.ConversionOperatorDeclaration:
                     {
-                        return WellKnownMemberNames.ImplicitConversionName;
+                        var operatorDecl = (ConversionOperatorDeclarationSyntax)declaration;
+                        return GetDeclarationName(declaration, operatorDecl.ExplicitInterfaceSpecifier, OperatorFacts.OperatorNameFromDeclaration(operatorDecl));
                     }
 
                 case SyntaxKind.EventFieldDeclaration:
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.Lowered.cs b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.Lowered.cs
index 7a3e6a8005652..e61efd3329cb3 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.Lowered.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.Lowered.cs
@@ -363,7 +363,7 @@ internal static BoundBlock ConstructSingleInvocationMethodBody(SyntheticBoundNod
                 argBuilder.Add(F.Parameter(param));
             }
 
-            BoundExpression invocation = F.Call(useBaseReference ? (BoundExpression)F.Base(baseType: methodToInvoke.ContainingType) : F.This(),
+            BoundExpression invocation = F.Call(methodToInvoke.IsStatic ? null : (useBaseReference ? (BoundExpression)F.Base(baseType: methodToInvoke.ContainingType) : F.This()),
                                                 methodToInvoke,
                                                 argBuilder.ToImmutableAndFree());
 
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
index 9d71f386260c9..7ac51f5d80b5f 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
@@ -493,6 +493,7 @@ internal static BoundBlock ConstructFieldLikeEventAccessorBody_Regular(SourceEve
                 right: boundTmps[1],
                 constantValueOpt: null,
                 methodOpt: null,
+                constrainedToTypeOpt: null,
                 resultKind: LookupResultKind.Viable,
                 type: boolType)
             { WasCompilerGenerated = true };
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 50568274f92c7..e07d3123407a9 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -811,7 +811,7 @@ private void CompileSynthesizedExplicitImplementations(SourceMemberContainerType
             if (!_globalHasErrors)
             {
                 var discardedDiagnostics = BindingDiagnosticBag.GetInstance(_diagnostics);
-                foreach (var synthesizedExplicitImpl in sourceTypeSymbol.GetSynthesizedExplicitImplementations(_cancellationToken))
+                foreach (var synthesizedExplicitImpl in sourceTypeSymbol.GetSynthesizedExplicitImplementations(_cancellationToken).ForwardingMethods)
                 {
                     Debug.Assert(synthesizedExplicitImpl.SynthesizesLoweredBoundBody);
                     synthesizedExplicitImpl.GenerateMethodBody(compilationState, discardedDiagnostics);
diff --git a/src/Compilers/CSharp/Portable/Compiler/SynthesizedMetadataCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/SynthesizedMetadataCompiler.cs
index ad17f08499d20..5509aef41b301 100644
--- a/src/Compilers/CSharp/Portable/Compiler/SynthesizedMetadataCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/SynthesizedMetadataCompiler.cs
@@ -72,7 +72,7 @@ public override void VisitNamedType(NamedTypeSymbol symbol)
                     // base type from another assembly) it is necessary for the compiler to generate explicit implementations for
                     // some interface methods.  They don't go in the symbol table, but if we are emitting metadata, then we should
                     // generate MethodDef entries for them.
-                    foreach (var synthesizedExplicitImpl in sourceTypeSymbol.GetSynthesizedExplicitImplementations(_cancellationToken))
+                    foreach (var synthesizedExplicitImpl in sourceTypeSymbol.GetSynthesizedExplicitImplementations(_cancellationToken).ForwardingMethods)
                     {
                         _moduleBeingBuilt.AddSynthesizedDefinition(symbol, synthesizedExplicitImpl.GetCciAdapter());
                     }
diff --git a/src/Compilers/CSharp/Portable/Declarations/DeclarationTable.cs b/src/Compilers/CSharp/Portable/Declarations/DeclarationTable.cs
index bb86bb544939a..545a231ba2223 100644
--- a/src/Compilers/CSharp/Portable/Declarations/DeclarationTable.cs
+++ b/src/Compilers/CSharp/Portable/Declarations/DeclarationTable.cs
@@ -278,7 +278,7 @@ public static bool ContainsName(
                 mergedRoot,
                 n => n == name,
                 filter,
-                t => t.MemberNames.Contains(name),
+                t => t.MemberNames.ContainsKey(name),
                 cancellationToken);
         }
 
@@ -292,7 +292,7 @@ public static bool ContainsName(
                 mergedRoot, predicate, filter,
                 t =>
                 {
-                    foreach (var name in t.MemberNames)
+                    foreach (var (name, _) in t.MemberNames)
                     {
                         if (predicate(name))
                         {
diff --git a/src/Compilers/CSharp/Portable/Declarations/DeclarationTreeBuilder.cs b/src/Compilers/CSharp/Portable/Declarations/DeclarationTreeBuilder.cs
index a71e95949fec6..4164baf567b67 100644
--- a/src/Compilers/CSharp/Portable/Declarations/DeclarationTreeBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Declarations/DeclarationTreeBuilder.cs
@@ -8,6 +8,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -58,6 +59,7 @@ private ImmutableArray<SingleNamespaceOrTypeDeclaration> VisitNamespaceChildren(
             bool isIterator = false;
             bool hasReturnWithExpression = false;
             GlobalStatementSyntax firstGlobalStatement = null;
+            bool hasNonEmptyGlobalSatement = false;
 
             var childrenBuilder = ArrayBuilder<SingleNamespaceOrTypeDeclaration>.GetInstance();
             foreach (var member in members)
@@ -73,6 +75,11 @@ private ImmutableArray<SingleNamespaceOrTypeDeclaration> VisitNamespaceChildren(
                     firstGlobalStatement ??= global;
                     var topLevelStatement = global.Statement;
 
+                    if (!topLevelStatement.IsKind(SyntaxKind.EmptyStatement))
+                    {
+                        hasNonEmptyGlobalSatement = true;
+                    }
+
                     if (!hasAwaitExpressions)
                     {
                         hasAwaitExpressions = SyntaxFacts.HasAwaitOperations(topLevelStatement);
@@ -97,7 +104,16 @@ private ImmutableArray<SingleNamespaceOrTypeDeclaration> VisitNamespaceChildren(
             // wrap all global statements in a compilation unit into a simple program type:
             if (firstGlobalStatement is object)
             {
-                childrenBuilder.Add(CreateSimpleProgram(firstGlobalStatement, hasAwaitExpressions, isIterator, hasReturnWithExpression));
+                var diagnostics = ImmutableArray<Diagnostic>.Empty;
+
+                if (!hasNonEmptyGlobalSatement)
+                {
+                    var bag = DiagnosticBag.GetInstance();
+                    bag.Add(ErrorCode.ERR_SimpleProgramIsEmpty, ((EmptyStatementSyntax)firstGlobalStatement.Statement).SemicolonToken.GetLocation());
+                    diagnostics = bag.ToReadOnlyAndFree();
+                }
+
+                childrenBuilder.Add(CreateSimpleProgram(firstGlobalStatement, hasAwaitExpressions, isIterator, hasReturnWithExpression, diagnostics));
             }
 
             // wrap all members that are defined in a namespace or compilation unit into an implicit type:
@@ -114,7 +130,7 @@ private ImmutableArray<SingleNamespaceOrTypeDeclaration> VisitNamespaceChildren(
             return childrenBuilder.ToImmutableAndFree();
         }
 
-        private static SingleNamespaceOrTypeDeclaration CreateImplicitClass(ImmutableHashSet<string> memberNames, SyntaxReference container, SingleTypeDeclaration.TypeDeclarationFlags declFlags)
+        private static SingleNamespaceOrTypeDeclaration CreateImplicitClass(ImmutableSegmentedDictionary<string, VoidResult> memberNames, SyntaxReference container, SingleTypeDeclaration.TypeDeclarationFlags declFlags)
         {
             return new SingleTypeDeclaration(
                 kind: DeclarationKind.ImplicitClass,
@@ -129,7 +145,7 @@ private static SingleNamespaceOrTypeDeclaration CreateImplicitClass(ImmutableHas
                 diagnostics: ImmutableArray<Diagnostic>.Empty);
         }
 
-        private static SingleNamespaceOrTypeDeclaration CreateSimpleProgram(GlobalStatementSyntax firstGlobalStatement, bool hasAwaitExpressions, bool isIterator, bool hasReturnWithExpression)
+        private static SingleNamespaceOrTypeDeclaration CreateSimpleProgram(GlobalStatementSyntax firstGlobalStatement, bool hasAwaitExpressions, bool isIterator, bool hasReturnWithExpression, ImmutableArray<Diagnostic> diagnostics)
         {
             return new SingleTypeDeclaration(
                 kind: DeclarationKind.SimpleProgram,
@@ -141,9 +157,9 @@ private static SingleNamespaceOrTypeDeclaration CreateSimpleProgram(GlobalStatem
                            (hasReturnWithExpression ? SingleTypeDeclaration.TypeDeclarationFlags.HasReturnWithExpression : SingleTypeDeclaration.TypeDeclarationFlags.None),
                 syntaxReference: firstGlobalStatement.SyntaxTree.GetReference(firstGlobalStatement.Parent),
                 nameLocation: new SourceLocation(firstGlobalStatement.GetFirstToken()),
-                memberNames: ImmutableHashSet<string>.Empty,
+                memberNames: ImmutableSegmentedDictionary<string, VoidResult>.Empty,
                 children: ImmutableArray<SingleTypeDeclaration>.Empty,
-                diagnostics: ImmutableArray<Diagnostic>.Empty);
+                diagnostics: diagnostics);
         }
 
         /// <summary>
@@ -209,7 +225,7 @@ private static ImmutableArray<ReferenceDirective> GetReferenceDirectives(Compila
         private SingleNamespaceOrTypeDeclaration CreateScriptClass(
             CompilationUnitSyntax parent,
             ImmutableArray<SingleTypeDeclaration> children,
-            ImmutableHashSet<string> memberNames,
+            ImmutableSegmentedDictionary<string, VoidResult> memberNames,
             SingleTypeDeclaration.TypeDeclarationFlags declFlags)
         {
             Debug.Assert(parent.Kind() == SyntaxKind.CompilationUnit && _syntaxTree.Options.Kind != SourceCodeKind.Regular);
@@ -510,7 +526,7 @@ public override SingleNamespaceOrTypeDeclaration VisitDelegateDeclaration(Delega
                 arity: node.Arity,
                 syntaxReference: _syntaxTree.GetReference(node),
                 nameLocation: new SourceLocation(node.Identifier),
-                memberNames: ImmutableHashSet<string>.Empty,
+                memberNames: ImmutableSegmentedDictionary<string, VoidResult>.Empty,
                 children: ImmutableArray<SingleTypeDeclaration>.Empty,
                 diagnostics: diagnostics.ToReadOnlyAndFree());
         }
@@ -528,7 +544,7 @@ public override SingleNamespaceOrTypeDeclaration VisitEnumDeclaration(EnumDeclar
                 declFlags |= SingleTypeDeclaration.TypeDeclarationFlags.HasBaseDeclarations;
             }
 
-            ImmutableHashSet<string> memberNames = GetEnumMemberNames(members, ref declFlags);
+            ImmutableSegmentedDictionary<string, VoidResult> memberNames = GetEnumMemberNames(members, ref declFlags);
 
             var diagnostics = DiagnosticBag.GetInstance();
             var modifiers = node.Modifiers.ToDeclarationModifiers(diagnostics: diagnostics);
@@ -546,10 +562,10 @@ public override SingleNamespaceOrTypeDeclaration VisitEnumDeclaration(EnumDeclar
                 diagnostics: diagnostics.ToReadOnlyAndFree());
         }
 
-        private static readonly ObjectPool<ImmutableHashSet<string>.Builder> s_memberNameBuilderPool =
-            new ObjectPool<ImmutableHashSet<string>.Builder>(() => ImmutableHashSet.CreateBuilder<string>());
+        private static readonly ObjectPool<ImmutableSegmentedDictionary<string, VoidResult>.Builder> s_memberNameBuilderPool =
+            new ObjectPool<ImmutableSegmentedDictionary<string, VoidResult>.Builder>(() => ImmutableSegmentedDictionary.CreateBuilder<string, VoidResult>());
 
-        private static ImmutableHashSet<string> ToImmutableAndFree(ImmutableHashSet<string>.Builder builder)
+        private static ImmutableSegmentedDictionary<string, VoidResult> ToImmutableAndFree(ImmutableSegmentedDictionary<string, VoidResult>.Builder builder)
         {
             var result = builder.ToImmutable();
             builder.Clear();
@@ -557,7 +573,7 @@ private static ImmutableHashSet<string> ToImmutableAndFree(ImmutableHashSet<stri
             return result;
         }
 
-        private static ImmutableHashSet<string> GetEnumMemberNames(SeparatedSyntaxList<EnumMemberDeclarationSyntax> members, ref SingleTypeDeclaration.TypeDeclarationFlags declFlags)
+        private static ImmutableSegmentedDictionary<string, VoidResult> GetEnumMemberNames(SeparatedSyntaxList<EnumMemberDeclarationSyntax> members, ref SingleTypeDeclaration.TypeDeclarationFlags declFlags)
         {
             var cnt = members.Count;
 
@@ -570,7 +586,7 @@ private static ImmutableHashSet<string> GetEnumMemberNames(SeparatedSyntaxList<E
             bool anyMemberHasAttributes = false;
             foreach (var member in members)
             {
-                memberNamesBuilder.Add(member.Identifier.ValueText);
+                memberNamesBuilder.TryAdd(member.Identifier.ValueText);
                 if (!anyMemberHasAttributes && member.AttributeLists.Any())
                 {
                     anyMemberHasAttributes = true;
@@ -585,7 +601,7 @@ private static ImmutableHashSet<string> GetEnumMemberNames(SeparatedSyntaxList<E
             return ToImmutableAndFree(memberNamesBuilder);
         }
 
-        private static ImmutableHashSet<string> GetNonTypeMemberNames(
+        private static ImmutableSegmentedDictionary<string, VoidResult> GetNonTypeMemberNames(
             CoreInternalSyntax.SyntaxList<Syntax.InternalSyntax.MemberDeclarationSyntax> members, ref SingleTypeDeclaration.TypeDeclarationFlags declFlags, bool skipGlobalStatements = false)
         {
             bool anyMethodHadExtensionSyntax = false;
@@ -707,7 +723,7 @@ private static bool CheckMemberForAttributes(Syntax.InternalSyntax.CSharpSyntaxN
         }
 
         private static void AddNonTypeMemberNames(
-            Syntax.InternalSyntax.CSharpSyntaxNode member, ImmutableHashSet<string>.Builder set, ref bool anyNonTypeMembers, bool skipGlobalStatements)
+            Syntax.InternalSyntax.CSharpSyntaxNode member, ImmutableSegmentedDictionary<string, VoidResult>.Builder set, ref bool anyNonTypeMembers, bool skipGlobalStatements)
         {
             switch (member.Kind)
             {
@@ -718,7 +734,7 @@ private static void AddNonTypeMemberNames(
                     int numFieldDeclarators = fieldDeclarators.Count;
                     for (int i = 0; i < numFieldDeclarators; i++)
                     {
-                        set.Add(fieldDeclarators[i].Identifier.ValueText);
+                        set.TryAdd(fieldDeclarators[i].Identifier.ValueText);
                     }
                     break;
 
@@ -729,7 +745,7 @@ private static void AddNonTypeMemberNames(
                     int numEventDeclarators = eventDeclarators.Count;
                     for (int i = 0; i < numEventDeclarators; i++)
                     {
-                        set.Add(eventDeclarators[i].Identifier.ValueText);
+                        set.TryAdd(eventDeclarators[i].Identifier.ValueText);
                     }
                     break;
 
@@ -742,7 +758,7 @@ private static void AddNonTypeMemberNames(
                     var methodDecl = (Syntax.InternalSyntax.MethodDeclarationSyntax)member;
                     if (methodDecl.ExplicitInterfaceSpecifier == null)
                     {
-                        set.Add(methodDecl.Identifier.ValueText);
+                        set.TryAdd(methodDecl.Identifier.ValueText);
                     }
                     break;
 
@@ -752,7 +768,7 @@ private static void AddNonTypeMemberNames(
                     var propertyDecl = (Syntax.InternalSyntax.PropertyDeclarationSyntax)member;
                     if (propertyDecl.ExplicitInterfaceSpecifier == null)
                     {
-                        set.Add(propertyDecl.Identifier.ValueText);
+                        set.TryAdd(propertyDecl.Identifier.ValueText);
                     }
                     break;
 
@@ -762,39 +778,55 @@ private static void AddNonTypeMemberNames(
                     var eventDecl = (Syntax.InternalSyntax.EventDeclarationSyntax)member;
                     if (eventDecl.ExplicitInterfaceSpecifier == null)
                     {
-                        set.Add(eventDecl.Identifier.ValueText);
+                        set.TryAdd(eventDecl.Identifier.ValueText);
                     }
                     break;
 
                 case SyntaxKind.ConstructorDeclaration:
                     anyNonTypeMembers = true;
-                    set.Add(((Syntax.InternalSyntax.ConstructorDeclarationSyntax)member).Modifiers.Any((int)SyntaxKind.StaticKeyword)
+                    set.TryAdd(((Syntax.InternalSyntax.ConstructorDeclarationSyntax)member).Modifiers.Any((int)SyntaxKind.StaticKeyword)
                         ? WellKnownMemberNames.StaticConstructorName
                         : WellKnownMemberNames.InstanceConstructorName);
                     break;
 
                 case SyntaxKind.DestructorDeclaration:
                     anyNonTypeMembers = true;
-                    set.Add(WellKnownMemberNames.DestructorName);
+                    set.TryAdd(WellKnownMemberNames.DestructorName);
                     break;
 
                 case SyntaxKind.IndexerDeclaration:
                     anyNonTypeMembers = true;
-                    set.Add(WellKnownMemberNames.Indexer);
+                    set.TryAdd(WellKnownMemberNames.Indexer);
                     break;
 
                 case SyntaxKind.OperatorDeclaration:
-                    anyNonTypeMembers = true;
-                    var opDecl = (Syntax.InternalSyntax.OperatorDeclarationSyntax)member;
-                    var name = OperatorFacts.OperatorNameFromDeclaration(opDecl);
-                    set.Add(name);
+                    {
+                        anyNonTypeMembers = true;
+
+                        // Handle in the same way as explicit method implementations
+                        var opDecl = (Syntax.InternalSyntax.OperatorDeclarationSyntax)member;
+
+                        if (opDecl.ExplicitInterfaceSpecifier == null)
+                        {
+                            var name = OperatorFacts.OperatorNameFromDeclaration(opDecl);
+                            set.TryAdd(name);
+                        }
+                    }
                     break;
 
                 case SyntaxKind.ConversionOperatorDeclaration:
-                    anyNonTypeMembers = true;
-                    set.Add(((Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax)member).ImplicitOrExplicitKeyword.Kind == SyntaxKind.ImplicitKeyword
-                        ? WellKnownMemberNames.ImplicitConversionName
-                        : WellKnownMemberNames.ExplicitConversionName);
+                    {
+                        anyNonTypeMembers = true;
+
+                        // Handle in the same way as explicit method implementations
+                        var opDecl = (Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax)member;
+
+                        if (opDecl.ExplicitInterfaceSpecifier == null)
+                        {
+                            var name = OperatorFacts.OperatorNameFromDeclaration(opDecl);
+                            set.TryAdd(name);
+                        }
+                    }
                     break;
 
                 case SyntaxKind.GlobalStatement:
diff --git a/src/Compilers/CSharp/Portable/Declarations/MergedTypeDeclaration.cs b/src/Compilers/CSharp/Portable/Declarations/MergedTypeDeclaration.cs
index 9728ae14c5b1b..c4f10a4bd1f4c 100644
--- a/src/Compilers/CSharp/Portable/Declarations/MergedTypeDeclaration.cs
+++ b/src/Compilers/CSharp/Portable/Declarations/MergedTypeDeclaration.cs
@@ -225,7 +225,7 @@ public ICollection<string> MemberNames
             {
                 if (_lazyMemberNames == null)
                 {
-                    var names = UnionCollection<string>.Create(this.Declarations, d => d.MemberNames);
+                    var names = UnionCollection<string>.Create(this.Declarations, d => d.MemberNames.Keys);
                     Interlocked.CompareExchange(ref _lazyMemberNames, names, null);
                 }
 
diff --git a/src/Compilers/CSharp/Portable/Declarations/SingleTypeDeclaration.cs b/src/Compilers/CSharp/Portable/Declarations/SingleTypeDeclaration.cs
index a00f630726af1..35f5d5be56847 100644
--- a/src/Compilers/CSharp/Portable/Declarations/SingleTypeDeclaration.cs
+++ b/src/Compilers/CSharp/Portable/Declarations/SingleTypeDeclaration.cs
@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.CodeAnalysis.Collections;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
@@ -53,7 +54,7 @@ internal SingleTypeDeclaration(
             TypeDeclarationFlags declFlags,
             SyntaxReference syntaxReference,
             SourceLocation nameLocation,
-            ImmutableHashSet<string> memberNames,
+            ImmutableSegmentedDictionary<string, VoidResult> memberNames,
             ImmutableArray<SingleTypeDeclaration> children,
             ImmutableArray<Diagnostic> diagnostics)
             : base(name, syntaxReference, nameLocation, diagnostics)
@@ -100,7 +101,7 @@ public DeclarationModifiers Modifiers
             }
         }
 
-        public ImmutableHashSet<string> MemberNames { get; }
+        public ImmutableSegmentedDictionary<string, VoidResult> MemberNames { get; }
 
         public bool AnyMemberHasExtensionMethodSyntax
         {
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs
index 0a5c663b9569e..377645bb42318 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs
@@ -378,6 +378,15 @@ Cci.ITypeReference Cci.ITypeDefinition.GetBaseClass(EmitContext context)
                 yield break;
             }
 
+            if (AdaptedNamedTypeSymbol is SourceMemberContainerTypeSymbol container)
+            {
+                foreach ((MethodSymbol body, MethodSymbol implemented) in container.GetSynthesizedExplicitImplementations(cancellationToken: default).MethodImpls)
+                {
+                    Debug.Assert(body.ContainingType == (object)container);
+                    yield return new Microsoft.Cci.MethodImplementation(body.GetCciAdapter(), moduleBeingBuilt.TranslateOverriddenMethodReference(implemented, (CSharpSyntaxNode)context.SyntaxNode, context.Diagnostics));
+                }
+            }
+
             var syntheticMethods = moduleBeingBuilt.GetSynthesizedMethods(AdaptedNamedTypeSymbol);
             if (syntheticMethods != null)
             {
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 1a1f62b393aaf..bb7a92cc988f7 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -1207,7 +1207,7 @@ internal enum ErrorCode
         //WRN_PDBConstantStringValueTooLong = 7063,     gave up on this warning
         ERR_CantOpenIcon = 7064,
         ERR_ErrorBuildingWin32Resources = 7065,
-        ERR_IteratorInInteractive = 7066,
+        // ERR_IteratorInInteractive = 7066,
         ERR_BadAttributeParamDefaultArgument = 7067,
         ERR_MissingTypeInSource = 7068,
         ERR_MissingTypeInAssembly = 7069,
@@ -1468,7 +1468,7 @@ internal enum ErrorCode
         ERR_PublicSignNetModule = 8202,
         ERR_BadAssemblyName = 8203,
         ERR_BadAsyncMethodBuilderTaskProperty = 8204,
-        ERR_AttributesInLocalFuncDecl = 8205,
+        // ERR_AttributesInLocalFuncDecl = 8205,
         ERR_TypeForwardedToMultipleAssemblies = 8206,
         ERR_ExpressionTreeContainsDiscard = 8207,
         ERR_PatternDynamicType = 8208,
@@ -1941,6 +1941,31 @@ internal enum ErrorCode
         ERR_CannotInferDelegateType = 8917,
         ERR_InvalidNameInSubpattern = 8918,
 
+        ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces = 8919,
+        ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers = 8920,
+        ERR_BadAbstractUnaryOperatorSignature = 8921,
+        ERR_BadAbstractIncDecSignature = 8922,
+        ERR_BadAbstractIncDecRetType = 8923,
+        ERR_BadAbstractBinaryOperatorSignature = 8924,
+        ERR_BadAbstractShiftOperatorSignature = 8925,
+        ERR_BadAbstractStaticMemberAccess = 8926,
+        ERR_ExpressionTreeContainsAbstractStaticMemberAccess = 8927,
+        ERR_CloseUnimplementedInterfaceMemberNotStatic = 8928,
+        ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember = 8929,
+        ERR_ExplicitImplementationOfOperatorsMustBeStatic = 8930,
+        ERR_AbstractConversionNotInvolvingContainedType = 8931,
+        ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod = 8932,
+        HDN_DuplicateWithGlobalUsing = 8933,
+        ERR_CantConvAnonMethReturnType = 8934,
+        ERR_BuilderAttributeDisallowed = 8935,
+        ERR_FeatureNotAvailableInVersion10 = 8936,
+        ERR_SimpleProgramIsEmpty = 8937,
+        ERR_LineSpanDirectiveInvalidValue = 8938,
+        ERR_LineSpanDirectiveEndLessThanStart = 8939,
+        ERR_WrongArityAsyncReturn = 8940,
+
+        #endregion
+
         ERR_InterpolatedStringHandlerMethodReturnMalformed = 9001,
         ERR_InterpolatedStringHandlerMethodReturnInconsistent = 9002,
         ERR_InterpolatedStringHandlerInvalidCreateMethod = 9003,
@@ -1957,8 +1982,6 @@ internal enum ErrorCode
         ERR_ExpressionTreeContainsInterpolatedStringHandlerConversion = 9014,
         ERR_InterpolatedStringHandlerCreationCannotUseDynamic = 9015,
 
-        #endregion diagnostics introduced for C# 10.0
-
         // Note: you will need to re-generate compiler code after adding warnings (eng\generate-compiler-code.cmd)
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Errors/MessageID.cs b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
index fa48284c0a58f..985355f253168 100644
--- a/src/Compilers/CSharp/Portable/Errors/MessageID.cs
+++ b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
@@ -227,6 +227,11 @@ internal enum MessageID
         IDS_FeatureImprovedInterpolatedStrings = MessageBase + 13000, // PROTOTYPE(interp-string): condense
         IDS_FeatureWithOnAnonymousTypes = MessageBase + 12801,
         IDS_FeatureExtendedPropertyPatterns = MessageBase + 12802,
+        IDS_FeatureStaticAbstractMembersInInterfaces = MessageBase + 12803,
+        IDS_FeatureLambdaReturnType = MessageBase + 12804,
+        IDS_AsyncMethodBuilderOverride = MessageBase + 12805,
+        IDS_FeatureImplicitImplementationOfNonPublicMemebers = MessageBase + 12806,
+        IDS_FeatureLineSpanDirective = MessageBase + 12807,
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -334,6 +339,10 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
             switch (feature)
             {
                 // C# preview features.
+                case MessageID.IDS_FeatureStaticAbstractMembersInInterfaces: // semantic check
+                    return LanguageVersion.Preview;
+
+                // C# 10.0 features.
                 case MessageID.IDS_FeatureMixedDeclarationsAndExpressionsInDeconstruction: // semantic check
                 case MessageID.IDS_FeatureSealedToStringInRecord: // semantic check
                 case MessageID.IDS_FeatureImprovedInterpolatedStrings: // semantic check
@@ -345,7 +354,12 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureInferredDelegateType: // semantic check
                 case MessageID.IDS_FeatureLambdaAttributes: // semantic check
                 case MessageID.IDS_FeatureExtendedPropertyPatterns:
-                    return LanguageVersion.Preview;
+                case MessageID.IDS_FeatureLambdaReturnType: // semantic check
+                case MessageID.IDS_AsyncMethodBuilderOverride: // semantic check
+                case MessageID.IDS_FeatureConstantInterpolatedStrings: // semantic check
+                case MessageID.IDS_FeatureImplicitImplementationOfNonPublicMemebers: // semantic check
+                case MessageID.IDS_FeatureLineSpanDirective:
+                    return LanguageVersion.CSharp10;
 
                 // C# 9.0 features.
                 case MessageID.IDS_FeatureLambdaDiscardParameters: // semantic check
@@ -372,12 +386,9 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureStaticAnonymousFunction: // syntax check
                 case MessageID.IDS_FeatureModuleInitializers: // semantic check on method attribute
                 case MessageID.IDS_FeatureDefaultTypeParameterConstraint:
+                case MessageID.IDS_FeatureVarianceSafetyForStaticInterfaceMembers: // semantic check
                     return LanguageVersion.CSharp9;
 
-                case MessageID.IDS_FeatureVarianceSafetyForStaticInterfaceMembers: //semantic check
-                case MessageID.IDS_FeatureConstantInterpolatedStrings: //semantic check
-                    return LanguageVersion.Preview;
-
                 // C# 8.0 features.
                 case MessageID.IDS_FeatureAltInterpolatedVerbatimStrings:
                 case MessageID.IDS_FeatureCoalesceAssignmentExpression:
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs
index a138883fe13ba..cb6480c0e4ef7 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs
@@ -40,7 +40,7 @@ public static BoundBlock Rewrite(
 #endif
             var compilation = method.DeclaringCompilation;
 
-            if (method.ReturnsVoid || method.IsIterator || method.IsAsyncReturningTask(compilation))
+            if (method.ReturnsVoid || method.IsIterator || method.IsAsyncEffectivelyReturningTask(compilation))
             {
                 // we don't analyze synthesized void methods.
                 if ((method.IsImplicitlyDeclared && !method.IsScriptInitializer) ||
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
index d42d98bcc92f6..73507e79b189c 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -143,6 +143,12 @@ public VisitArgumentResult(VisitResult visitResult, Optional<LocalState> stateFo
         /// </summary>
         private bool _useDelegateInvokeParameterTypes;
 
+        /// <summary>
+        /// If true, the return type and nullability from _delegateInvokeMethod is used.
+        /// If false, the signature of CurrentSymbol is used instead.
+        /// </summary>
+        private bool _useDelegateInvokeReturnType;
+
         /// <summary>
         /// Method signature used for return or parameter types. Distinct from CurrentSymbol signature
         /// when CurrentSymbol is a lambda and type is inferred from MethodTypeInferrer.
@@ -377,6 +383,7 @@ private NullableWalker(
             Symbol? symbol,
             bool useConstructorExitWarnings,
             bool useDelegateInvokeParameterTypes,
+            bool useDelegateInvokeReturnType,
             MethodSymbol? delegateInvokeMethodOpt,
             BoundNode node,
             Binder binder,
@@ -395,6 +402,7 @@ private NullableWalker(
             _conversions = (Conversions)conversions.WithNullability(true);
             _useConstructorExitWarnings = useConstructorExitWarnings;
             _useDelegateInvokeParameterTypes = useDelegateInvokeParameterTypes;
+            _useDelegateInvokeReturnType = useDelegateInvokeReturnType;
             _delegateInvokeMethod = delegateInvokeMethodOpt;
             _analyzedNullabilityMapOpt = analyzedNullabilityMapOpt;
             _returnTypesOpt = returnTypesOpt;
@@ -1073,6 +1081,7 @@ private static void Analyze(
                 diagnostics,
                 useConstructorExitWarnings,
                 useDelegateInvokeParameterTypes: false,
+                useDelegateInvokeReturnType: false,
                 delegateInvokeMethodOpt: null,
                 initialState: initialNullableState,
                 analyzedNullabilityMapOpt: null,
@@ -1176,6 +1185,7 @@ private static (SnapshotManager?, ImmutableDictionary<BoundExpression, (Nullabil
                 diagnostics,
                 useConstructorExitWarnings: true,
                 useDelegateInvokeParameterTypes: false,
+                useDelegateInvokeReturnType: false,
                 delegateInvokeMethodOpt: null,
                 initialState,
                 analyzedNullabilities,
@@ -1225,6 +1235,7 @@ internal static BoundNode AnalyzeAndRewriteSpeculation(
                 symbol,
                 useConstructorExitWarnings: false,
                 useDelegateInvokeParameterTypes: false,
+                useDelegateInvokeReturnType: false,
                 delegateInvokeMethodOpt: null,
                 node,
                 binder,
@@ -1312,6 +1323,7 @@ internal static void AnalyzeIfNeeded(
                 diagnostics,
                 useConstructorExitWarnings: false,
                 useDelegateInvokeParameterTypes: false,
+                useDelegateInvokeReturnType: false,
                 delegateInvokeMethodOpt: null,
                 initialState: null,
                 analyzedNullabilityMapOpt: null,
@@ -1333,11 +1345,13 @@ internal static void Analyze(
         {
             var symbol = lambda.Symbol;
             var variables = Variables.Create(initialState.Variables).CreateNestedMethodScope(symbol);
+            UseDelegateInvokeParameterAndReturnTypes(lambda, delegateInvokeMethodOpt, out bool useDelegateInvokeParameterTypes, out bool useDelegateInvokeReturnType);
             var walker = new NullableWalker(
                 compilation,
                 symbol,
                 useConstructorExitWarnings: false,
-                useDelegateInvokeParameterTypes: UseDelegateInvokeParameterTypes(lambda, delegateInvokeMethodOpt),
+                useDelegateInvokeParameterTypes: useDelegateInvokeParameterTypes,
+                useDelegateInvokeReturnType: useDelegateInvokeReturnType,
                 delegateInvokeMethodOpt: delegateInvokeMethodOpt,
                 lambda.Body,
                 lambda.Binder,
@@ -1366,6 +1380,7 @@ private static void Analyze(
             DiagnosticBag diagnostics,
             bool useConstructorExitWarnings,
             bool useDelegateInvokeParameterTypes,
+            bool useDelegateInvokeReturnType,
             MethodSymbol? delegateInvokeMethodOpt,
             VariableState? initialState,
             ImmutableDictionary<BoundExpression, (NullabilityInfo, TypeSymbol?)>.Builder? analyzedNullabilityMapOpt,
@@ -1380,6 +1395,7 @@ private static void Analyze(
                                             symbol,
                                             useConstructorExitWarnings,
                                             useDelegateInvokeParameterTypes,
+                                            useDelegateInvokeReturnType,
                                             delegateInvokeMethodOpt,
                                             node,
                                             binder,
@@ -2524,7 +2540,7 @@ private bool TryGetReturnType(out TypeWithAnnotations type, out FlowAnalysisAnno
                 return false;
             }
 
-            var delegateOrMethod = _delegateInvokeMethod ?? method;
+            var delegateOrMethod = _useDelegateInvokeReturnType ? _delegateInvokeMethod! : method;
             var returnType = delegateOrMethod.ReturnTypeWithAnnotations;
             Debug.Assert((object)returnType != LambdaSymbol.ReturnTypeIsBeingInferred);
 
@@ -2542,7 +2558,7 @@ private bool TryGetReturnType(out TypeWithAnnotations type, out FlowAnalysisAnno
                 return true;
             }
 
-            if (returnType.Type.IsGenericTaskType(compilation))
+            if (method.IsAsyncEffectivelyReturningGenericTask(compilation))
             {
                 type = ((NamedTypeSymbol)returnType.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single();
                 annotations = FlowAnalysisAnnotations.None;
@@ -2650,7 +2666,8 @@ private void VisitStatementsWithLocalFunctions(BoundBlock block)
                 localFunc,
                 state,
                 delegateInvokeMethod: null,
-                useDelegateInvokeParameterTypes: false);
+                useDelegateInvokeParameterTypes: false,
+                useDelegateInvokeReturnType: false);
 
             SetInvalidResult();
 
@@ -2674,16 +2691,21 @@ private void AnalyzeLocalFunctionOrLambda(
             MethodSymbol lambdaOrFunctionSymbol,
             LocalState state,
             MethodSymbol? delegateInvokeMethod,
-            bool useDelegateInvokeParameterTypes)
+            bool useDelegateInvokeParameterTypes,
+            bool useDelegateInvokeReturnType)
         {
+            Debug.Assert(!useDelegateInvokeParameterTypes || delegateInvokeMethod is object);
+            Debug.Assert(!useDelegateInvokeReturnType || delegateInvokeMethod is object);
+
             var oldSymbol = this.CurrentSymbol;
             this.CurrentSymbol = lambdaOrFunctionSymbol;
 
-            Debug.Assert(!useDelegateInvokeParameterTypes || delegateInvokeMethod is object);
             var oldDelegateInvokeMethod = _delegateInvokeMethod;
             _delegateInvokeMethod = delegateInvokeMethod;
             var oldUseDelegateInvokeParameterTypes = _useDelegateInvokeParameterTypes;
             _useDelegateInvokeParameterTypes = useDelegateInvokeParameterTypes;
+            var oldUseDelegateInvokeReturnType = _useDelegateInvokeReturnType;
+            _useDelegateInvokeReturnType = useDelegateInvokeReturnType;
 
             var oldReturnTypes = _returnTypesOpt;
             _returnTypesOpt = null;
@@ -2721,6 +2743,7 @@ private void AnalyzeLocalFunctionOrLambda(
             _variables = _variables.Container!;
             this.State = oldState;
             _returnTypesOpt = oldReturnTypes;
+            _useDelegateInvokeReturnType = oldUseDelegateInvokeReturnType;
             _useDelegateInvokeParameterTypes = oldUseDelegateInvokeParameterTypes;
             _delegateInvokeMethod = oldDelegateInvokeMethod;
             this.CurrentSymbol = oldSymbol;
@@ -3471,6 +3494,7 @@ internal static TypeWithAnnotations BestTypeForLambdaReturns(
                                             symbol: null,
                                             useConstructorExitWarnings: false,
                                             useDelegateInvokeParameterTypes: false,
+                                            useDelegateInvokeReturnType: false,
                                             delegateInvokeMethodOpt: null,
                                             node,
                                             binder,
@@ -6786,6 +6810,15 @@ private void ReportNullabilityMismatchWithTargetDelegate(Location location, Name
             }
 
             Debug.Assert(delegateType is object);
+
+            if (unboundLambda.HasExplicitReturnType(out _, out var returnType) &&
+                IsNullabilityMismatch(invoke.ReturnTypeWithAnnotations, returnType, requireIdentity: true))
+            {
+                ReportDiagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, location,
+                    unboundLambda.MessageID.Localize(),
+                    delegateType);
+            }
+
             int count = Math.Min(invoke.ParameterCount, unboundLambda.ParameterCount);
             for (int i = 0; i < count; i++)
             {
@@ -7761,7 +7794,7 @@ private void VisitLambda(BoundLambda node, NamedTypeSymbol? delegateTypeOpt, Opt
             Debug.Assert(delegateTypeOpt?.IsDelegateType() != false);
 
             var delegateInvokeMethod = delegateTypeOpt?.DelegateInvokeMethod;
-            bool useDelegateInvokeParameterTypes = UseDelegateInvokeParameterTypes(node, delegateInvokeMethod);
+            UseDelegateInvokeParameterAndReturnTypes(node, delegateInvokeMethod, out bool useDelegateInvokeParameterTypes, out bool useDelegateInvokeReturnType);
             if (useDelegateInvokeParameterTypes && _snapshotBuilderOpt is object)
             {
                 SetUpdatedSymbol(node, node.Symbol, delegateTypeOpt!);
@@ -7772,12 +7805,23 @@ private void VisitLambda(BoundLambda node, NamedTypeSymbol? delegateTypeOpt, Opt
                 node.Symbol,
                 initialState.HasValue ? initialState.Value : State.Clone(),
                 delegateInvokeMethod,
-                useDelegateInvokeParameterTypes);
+                useDelegateInvokeParameterTypes,
+                useDelegateInvokeReturnType);
         }
 
-        private static bool UseDelegateInvokeParameterTypes(BoundLambda lambda, MethodSymbol? delegateInvokeMethod)
+        private static void UseDelegateInvokeParameterAndReturnTypes(BoundLambda lambda, MethodSymbol? delegateInvokeMethod, out bool useDelegateInvokeParameterTypes, out bool useDelegateInvokeReturnType)
         {
-            return delegateInvokeMethod is object && !lambda.UnboundLambda.HasExplicitlyTypedParameterList;
+            if (delegateInvokeMethod is null)
+            {
+                useDelegateInvokeParameterTypes = false;
+                useDelegateInvokeReturnType = false;
+            }
+            else
+            {
+                var unboundLambda = lambda.UnboundLambda;
+                useDelegateInvokeParameterTypes = !unboundLambda.HasExplicitlyTypedParameterList;
+                useDelegateInvokeReturnType = !unboundLambda.HasExplicitReturnType(out _, out _);
+            }
         }
 
         public override BoundNode? VisitUnboundLambda(UnboundLambda node)
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index a317f5f3127bb..fa2e11b51b2df 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -880,7 +880,7 @@ public BoundNamespaceExpression Update(NamespaceSymbol namespaceSymbol, AliasSym
 
     internal sealed partial class BoundUnaryOperator : BoundExpression
     {
-        public BoundUnaryOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind, BoundExpression operand, ConstantValue? constantValueOpt, MethodSymbol? methodOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, TypeSymbol type, bool hasErrors = false)
+        public BoundUnaryOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind, BoundExpression operand, ConstantValue? constantValueOpt, MethodSymbol? methodOpt, TypeSymbol? constrainedToTypeOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.UnaryOperator, syntax, type, hasErrors || operand.HasErrors())
         {
 
@@ -891,6 +891,7 @@ public BoundUnaryOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind, Bou
             this.Operand = operand;
             this.ConstantValueOpt = constantValueOpt;
             this.MethodOpt = methodOpt;
+            this.ConstrainedToTypeOpt = constrainedToTypeOpt;
             this._ResultKind = resultKind;
             this.OriginalUserDefinedOperatorsOpt = originalUserDefinedOperatorsOpt;
         }
@@ -906,6 +907,8 @@ public BoundUnaryOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind, Bou
 
         public MethodSymbol? MethodOpt { get; }
 
+        public TypeSymbol? ConstrainedToTypeOpt { get; }
+
         private readonly LookupResultKind _ResultKind;
         public override LookupResultKind ResultKind { get { return _ResultKind; } }
 
@@ -913,11 +916,11 @@ public BoundUnaryOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind, Bou
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitUnaryOperator(this);
 
-        public BoundUnaryOperator Update(UnaryOperatorKind operatorKind, BoundExpression operand, ConstantValue? constantValueOpt, MethodSymbol? methodOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, TypeSymbol type)
+        public BoundUnaryOperator Update(UnaryOperatorKind operatorKind, BoundExpression operand, ConstantValue? constantValueOpt, MethodSymbol? methodOpt, TypeSymbol? constrainedToTypeOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, TypeSymbol type)
         {
-            if (operatorKind != this.OperatorKind || operand != this.Operand || constantValueOpt != this.ConstantValueOpt || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(methodOpt, this.MethodOpt) || resultKind != this.ResultKind || originalUserDefinedOperatorsOpt != this.OriginalUserDefinedOperatorsOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (operatorKind != this.OperatorKind || operand != this.Operand || constantValueOpt != this.ConstantValueOpt || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(methodOpt, this.MethodOpt) || !TypeSymbol.Equals(constrainedToTypeOpt, this.ConstrainedToTypeOpt, TypeCompareKind.ConsiderEverything) || resultKind != this.ResultKind || originalUserDefinedOperatorsOpt != this.OriginalUserDefinedOperatorsOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
             {
-                var result = new BoundUnaryOperator(this.Syntax, operatorKind, operand, constantValueOpt, methodOpt, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors);
+                var result = new BoundUnaryOperator(this.Syntax, operatorKind, operand, constantValueOpt, methodOpt, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -927,7 +930,7 @@ public BoundUnaryOperator Update(UnaryOperatorKind operatorKind, BoundExpression
 
     internal sealed partial class BoundIncrementOperator : BoundExpression
     {
-        public BoundIncrementOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind, BoundExpression operand, MethodSymbol? methodOpt, Conversion operandConversion, Conversion resultConversion, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, TypeSymbol type, bool hasErrors = false)
+        public BoundIncrementOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind, BoundExpression operand, MethodSymbol? methodOpt, TypeSymbol? constrainedToTypeOpt, Conversion operandConversion, Conversion resultConversion, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.IncrementOperator, syntax, type, hasErrors || operand.HasErrors())
         {
 
@@ -937,6 +940,7 @@ public BoundIncrementOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind,
             this.OperatorKind = operatorKind;
             this.Operand = operand;
             this.MethodOpt = methodOpt;
+            this.ConstrainedToTypeOpt = constrainedToTypeOpt;
             this.OperandConversion = operandConversion;
             this.ResultConversion = resultConversion;
             this._ResultKind = resultKind;
@@ -952,6 +956,8 @@ public BoundIncrementOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind,
 
         public MethodSymbol? MethodOpt { get; }
 
+        public TypeSymbol? ConstrainedToTypeOpt { get; }
+
         public Conversion OperandConversion { get; }
 
         public Conversion ResultConversion { get; }
@@ -963,11 +969,11 @@ public BoundIncrementOperator(SyntaxNode syntax, UnaryOperatorKind operatorKind,
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitIncrementOperator(this);
 
-        public BoundIncrementOperator Update(UnaryOperatorKind operatorKind, BoundExpression operand, MethodSymbol? methodOpt, Conversion operandConversion, Conversion resultConversion, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, TypeSymbol type)
+        public BoundIncrementOperator Update(UnaryOperatorKind operatorKind, BoundExpression operand, MethodSymbol? methodOpt, TypeSymbol? constrainedToTypeOpt, Conversion operandConversion, Conversion resultConversion, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, TypeSymbol type)
         {
-            if (operatorKind != this.OperatorKind || operand != this.Operand || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(methodOpt, this.MethodOpt) || operandConversion != this.OperandConversion || resultConversion != this.ResultConversion || resultKind != this.ResultKind || originalUserDefinedOperatorsOpt != this.OriginalUserDefinedOperatorsOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (operatorKind != this.OperatorKind || operand != this.Operand || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(methodOpt, this.MethodOpt) || !TypeSymbol.Equals(constrainedToTypeOpt, this.ConstrainedToTypeOpt, TypeCompareKind.ConsiderEverything) || operandConversion != this.OperandConversion || resultConversion != this.ResultConversion || resultKind != this.ResultKind || originalUserDefinedOperatorsOpt != this.OriginalUserDefinedOperatorsOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
             {
-                var result = new BoundIncrementOperator(this.Syntax, operatorKind, operand, methodOpt, operandConversion, resultConversion, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors);
+                var result = new BoundIncrementOperator(this.Syntax, operatorKind, operand, methodOpt, constrainedToTypeOpt, operandConversion, resultConversion, resultKind, originalUserDefinedOperatorsOpt, type, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -1041,7 +1047,7 @@ public BoundUnconvertedAddressOfOperator Update(BoundMethodGroup operand)
 
     internal sealed partial class BoundFunctionPointerLoad : BoundExpression
     {
-        public BoundFunctionPointerLoad(SyntaxNode syntax, MethodSymbol targetMethod, TypeSymbol type, bool hasErrors)
+        public BoundFunctionPointerLoad(SyntaxNode syntax, MethodSymbol targetMethod, TypeSymbol? constrainedToTypeOpt, TypeSymbol type, bool hasErrors)
             : base(BoundKind.FunctionPointerLoad, syntax, type, hasErrors)
         {
 
@@ -1049,9 +1055,10 @@ public BoundFunctionPointerLoad(SyntaxNode syntax, MethodSymbol targetMethod, Ty
             RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
 
             this.TargetMethod = targetMethod;
+            this.ConstrainedToTypeOpt = constrainedToTypeOpt;
         }
 
-        public BoundFunctionPointerLoad(SyntaxNode syntax, MethodSymbol targetMethod, TypeSymbol type)
+        public BoundFunctionPointerLoad(SyntaxNode syntax, MethodSymbol targetMethod, TypeSymbol? constrainedToTypeOpt, TypeSymbol type)
             : base(BoundKind.FunctionPointerLoad, syntax, type)
         {
 
@@ -1059,20 +1066,23 @@ public BoundFunctionPointerLoad(SyntaxNode syntax, MethodSymbol targetMethod, Ty
             RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
 
             this.TargetMethod = targetMethod;
+            this.ConstrainedToTypeOpt = constrainedToTypeOpt;
         }
 
 
         public MethodSymbol TargetMethod { get; }
 
+        public TypeSymbol? ConstrainedToTypeOpt { get; }
+
         public new TypeSymbol Type => base.Type!;
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitFunctionPointerLoad(this);
 
-        public BoundFunctionPointerLoad Update(MethodSymbol targetMethod, TypeSymbol type)
+        public BoundFunctionPointerLoad Update(MethodSymbol targetMethod, TypeSymbol? constrainedToTypeOpt, TypeSymbol type)
         {
-            if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(targetMethod, this.TargetMethod) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(targetMethod, this.TargetMethod) || !TypeSymbol.Equals(constrainedToTypeOpt, this.ConstrainedToTypeOpt, TypeCompareKind.ConsiderEverything) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
             {
-                var result = new BoundFunctionPointerLoad(this.Syntax, targetMethod, type, this.HasErrors);
+                var result = new BoundFunctionPointerLoad(this.Syntax, targetMethod, constrainedToTypeOpt, type, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -1384,7 +1394,7 @@ protected BoundBinaryOperatorBase(BoundKind kind, SyntaxNode syntax, BoundExpres
 
     internal sealed partial class BoundBinaryOperator : BoundBinaryOperatorBase
     {
-        public BoundBinaryOperator(SyntaxNode syntax, BinaryOperatorKind operatorKind, ConstantValue? constantValueOpt, MethodSymbol? methodOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, BoundExpression left, BoundExpression right, TypeSymbol type, bool hasErrors = false)
+        public BoundBinaryOperator(SyntaxNode syntax, BinaryOperatorKind operatorKind, ConstantValue? constantValueOpt, MethodSymbol? methodOpt, TypeSymbol? constrainedToTypeOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, BoundExpression left, BoundExpression right, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.BinaryOperator, syntax, left, right, type, hasErrors || left.HasErrors() || right.HasErrors())
         {
 
@@ -1395,6 +1405,7 @@ public BoundBinaryOperator(SyntaxNode syntax, BinaryOperatorKind operatorKind, C
             this.OperatorKind = operatorKind;
             this.ConstantValueOpt = constantValueOpt;
             this.MethodOpt = methodOpt;
+            this.ConstrainedToTypeOpt = constrainedToTypeOpt;
             this._ResultKind = resultKind;
             this.OriginalUserDefinedOperatorsOpt = originalUserDefinedOperatorsOpt;
         }
@@ -1406,6 +1417,8 @@ public BoundBinaryOperator(SyntaxNode syntax, BinaryOperatorKind operatorKind, C
 
         public MethodSymbol? MethodOpt { get; }
 
+        public TypeSymbol? ConstrainedToTypeOpt { get; }
+
         private readonly LookupResultKind _ResultKind;
         public override LookupResultKind ResultKind { get { return _ResultKind; } }
 
@@ -1413,11 +1426,11 @@ public BoundBinaryOperator(SyntaxNode syntax, BinaryOperatorKind operatorKind, C
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitBinaryOperator(this);
 
-        public BoundBinaryOperator Update(BinaryOperatorKind operatorKind, ConstantValue? constantValueOpt, MethodSymbol? methodOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, BoundExpression left, BoundExpression right, TypeSymbol type)
+        public BoundBinaryOperator Update(BinaryOperatorKind operatorKind, ConstantValue? constantValueOpt, MethodSymbol? methodOpt, TypeSymbol? constrainedToTypeOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, BoundExpression left, BoundExpression right, TypeSymbol type)
         {
-            if (operatorKind != this.OperatorKind || constantValueOpt != this.ConstantValueOpt || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(methodOpt, this.MethodOpt) || resultKind != this.ResultKind || originalUserDefinedOperatorsOpt != this.OriginalUserDefinedOperatorsOpt || left != this.Left || right != this.Right || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (operatorKind != this.OperatorKind || constantValueOpt != this.ConstantValueOpt || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(methodOpt, this.MethodOpt) || !TypeSymbol.Equals(constrainedToTypeOpt, this.ConstrainedToTypeOpt, TypeCompareKind.ConsiderEverything) || resultKind != this.ResultKind || originalUserDefinedOperatorsOpt != this.OriginalUserDefinedOperatorsOpt || left != this.Left || right != this.Right || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
             {
-                var result = new BoundBinaryOperator(this.Syntax, operatorKind, constantValueOpt, methodOpt, resultKind, originalUserDefinedOperatorsOpt, left, right, type, this.HasErrors);
+                var result = new BoundBinaryOperator(this.Syntax, operatorKind, constantValueOpt, methodOpt, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt, left, right, type, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -1469,7 +1482,7 @@ public BoundTupleBinaryOperator Update(BoundExpression left, BoundExpression rig
 
     internal sealed partial class BoundUserDefinedConditionalLogicalOperator : BoundBinaryOperatorBase
     {
-        public BoundUserDefinedConditionalLogicalOperator(SyntaxNode syntax, BinaryOperatorKind operatorKind, MethodSymbol logicalOperator, MethodSymbol trueOperator, MethodSymbol falseOperator, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, BoundExpression left, BoundExpression right, TypeSymbol type, bool hasErrors = false)
+        public BoundUserDefinedConditionalLogicalOperator(SyntaxNode syntax, BinaryOperatorKind operatorKind, MethodSymbol logicalOperator, MethodSymbol trueOperator, MethodSymbol falseOperator, TypeSymbol? constrainedToTypeOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, BoundExpression left, BoundExpression right, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.UserDefinedConditionalLogicalOperator, syntax, left, right, type, hasErrors || left.HasErrors() || right.HasErrors())
         {
 
@@ -1484,6 +1497,7 @@ public BoundUserDefinedConditionalLogicalOperator(SyntaxNode syntax, BinaryOpera
             this.LogicalOperator = logicalOperator;
             this.TrueOperator = trueOperator;
             this.FalseOperator = falseOperator;
+            this.ConstrainedToTypeOpt = constrainedToTypeOpt;
             this._ResultKind = resultKind;
             this.OriginalUserDefinedOperatorsOpt = originalUserDefinedOperatorsOpt;
         }
@@ -1497,6 +1511,8 @@ public BoundUserDefinedConditionalLogicalOperator(SyntaxNode syntax, BinaryOpera
 
         public MethodSymbol FalseOperator { get; }
 
+        public TypeSymbol? ConstrainedToTypeOpt { get; }
+
         private readonly LookupResultKind _ResultKind;
         public override LookupResultKind ResultKind { get { return _ResultKind; } }
 
@@ -1504,11 +1520,11 @@ public BoundUserDefinedConditionalLogicalOperator(SyntaxNode syntax, BinaryOpera
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitUserDefinedConditionalLogicalOperator(this);
 
-        public BoundUserDefinedConditionalLogicalOperator Update(BinaryOperatorKind operatorKind, MethodSymbol logicalOperator, MethodSymbol trueOperator, MethodSymbol falseOperator, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, BoundExpression left, BoundExpression right, TypeSymbol type)
+        public BoundUserDefinedConditionalLogicalOperator Update(BinaryOperatorKind operatorKind, MethodSymbol logicalOperator, MethodSymbol trueOperator, MethodSymbol falseOperator, TypeSymbol? constrainedToTypeOpt, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, BoundExpression left, BoundExpression right, TypeSymbol type)
         {
-            if (operatorKind != this.OperatorKind || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(logicalOperator, this.LogicalOperator) || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(trueOperator, this.TrueOperator) || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(falseOperator, this.FalseOperator) || resultKind != this.ResultKind || originalUserDefinedOperatorsOpt != this.OriginalUserDefinedOperatorsOpt || left != this.Left || right != this.Right || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (operatorKind != this.OperatorKind || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(logicalOperator, this.LogicalOperator) || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(trueOperator, this.TrueOperator) || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(falseOperator, this.FalseOperator) || !TypeSymbol.Equals(constrainedToTypeOpt, this.ConstrainedToTypeOpt, TypeCompareKind.ConsiderEverything) || resultKind != this.ResultKind || originalUserDefinedOperatorsOpt != this.OriginalUserDefinedOperatorsOpt || left != this.Left || right != this.Right || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
             {
-                var result = new BoundUserDefinedConditionalLogicalOperator(this.Syntax, operatorKind, logicalOperator, trueOperator, falseOperator, resultKind, originalUserDefinedOperatorsOpt, left, right, type, this.HasErrors);
+                var result = new BoundUserDefinedConditionalLogicalOperator(this.Syntax, operatorKind, logicalOperator, trueOperator, falseOperator, constrainedToTypeOpt, resultKind, originalUserDefinedOperatorsOpt, left, right, type, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -10026,14 +10042,16 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
         public override BoundNode? VisitUnaryOperator(BoundUnaryOperator node)
         {
             BoundExpression operand = (BoundExpression)this.Visit(node.Operand);
+            TypeSymbol? constrainedToTypeOpt = this.VisitType(node.ConstrainedToTypeOpt);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, type);
+            return node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, constrainedToTypeOpt, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, type);
         }
         public override BoundNode? VisitIncrementOperator(BoundIncrementOperator node)
         {
             BoundExpression operand = (BoundExpression)this.Visit(node.Operand);
+            TypeSymbol? constrainedToTypeOpt = this.VisitType(node.ConstrainedToTypeOpt);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(node.OperatorKind, operand, node.MethodOpt, node.OperandConversion, node.ResultConversion, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, type);
+            return node.Update(node.OperatorKind, operand, node.MethodOpt, constrainedToTypeOpt, node.OperandConversion, node.ResultConversion, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, type);
         }
         public override BoundNode? VisitAddressOfOperator(BoundAddressOfOperator node)
         {
@@ -10049,8 +10067,9 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
         }
         public override BoundNode? VisitFunctionPointerLoad(BoundFunctionPointerLoad node)
         {
+            TypeSymbol? constrainedToTypeOpt = this.VisitType(node.ConstrainedToTypeOpt);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(node.TargetMethod, type);
+            return node.Update(node.TargetMethod, constrainedToTypeOpt, type);
         }
         public override BoundNode? VisitPointerIndirectionOperator(BoundPointerIndirectionOperator node)
         {
@@ -10107,8 +10126,9 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
         {
             BoundExpression left = (BoundExpression)this.Visit(node.Left);
             BoundExpression right = (BoundExpression)this.Visit(node.Right);
+            TypeSymbol? constrainedToTypeOpt = this.VisitType(node.ConstrainedToTypeOpt);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(node.OperatorKind, node.ConstantValueOpt, node.MethodOpt, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, left, right, type);
+            return node.Update(node.OperatorKind, node.ConstantValueOpt, node.MethodOpt, constrainedToTypeOpt, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, left, right, type);
         }
         public override BoundNode? VisitTupleBinaryOperator(BoundTupleBinaryOperator node)
         {
@@ -10121,8 +10141,9 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
         {
             BoundExpression left = (BoundExpression)this.Visit(node.Left);
             BoundExpression right = (BoundExpression)this.Visit(node.Right);
+            TypeSymbol? constrainedToTypeOpt = this.VisitType(node.ConstrainedToTypeOpt);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(node.OperatorKind, node.LogicalOperator, node.TrueOperator, node.FalseOperator, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, left, right, type);
+            return node.Update(node.OperatorKind, node.LogicalOperator, node.TrueOperator, node.FalseOperator, constrainedToTypeOpt, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, left, right, type);
         }
         public override BoundNode? VisitCompoundAssignmentOperator(BoundCompoundAssignmentOperator node)
         {
@@ -11344,18 +11365,19 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
         public override BoundNode? VisitUnaryOperator(BoundUnaryOperator node)
         {
             MethodSymbol? methodOpt = GetUpdatedSymbol(node, node.MethodOpt);
+            TypeSymbol? constrainedToTypeOpt = GetUpdatedSymbol(node, node.ConstrainedToTypeOpt);
             ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt = GetUpdatedArray(node, node.OriginalUserDefinedOperatorsOpt);
             BoundExpression operand = (BoundExpression)this.Visit(node.Operand);
             BoundUnaryOperator updatedNode;
 
             if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
             {
-                updatedNode = node.Update(node.OperatorKind, operand, node.ConstantValueOpt, methodOpt, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, infoAndType.Type!);
+                updatedNode = node.Update(node.OperatorKind, operand, node.ConstantValueOpt, methodOpt, constrainedToTypeOpt, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, infoAndType.Type!);
                 updatedNode.TopLevelNullability = infoAndType.Info;
             }
             else
             {
-                updatedNode = node.Update(node.OperatorKind, operand, node.ConstantValueOpt, methodOpt, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, node.Type);
+                updatedNode = node.Update(node.OperatorKind, operand, node.ConstantValueOpt, methodOpt, constrainedToTypeOpt, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, node.Type);
             }
             return updatedNode;
         }
@@ -11363,18 +11385,19 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
         public override BoundNode? VisitIncrementOperator(BoundIncrementOperator node)
         {
             MethodSymbol? methodOpt = GetUpdatedSymbol(node, node.MethodOpt);
+            TypeSymbol? constrainedToTypeOpt = GetUpdatedSymbol(node, node.ConstrainedToTypeOpt);
             ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt = GetUpdatedArray(node, node.OriginalUserDefinedOperatorsOpt);
             BoundExpression operand = (BoundExpression)this.Visit(node.Operand);
             BoundIncrementOperator updatedNode;
 
             if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
             {
-                updatedNode = node.Update(node.OperatorKind, operand, methodOpt, node.OperandConversion, node.ResultConversion, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, infoAndType.Type!);
+                updatedNode = node.Update(node.OperatorKind, operand, methodOpt, constrainedToTypeOpt, node.OperandConversion, node.ResultConversion, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, infoAndType.Type!);
                 updatedNode.TopLevelNullability = infoAndType.Info;
             }
             else
             {
-                updatedNode = node.Update(node.OperatorKind, operand, methodOpt, node.OperandConversion, node.ResultConversion, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, node.Type);
+                updatedNode = node.Update(node.OperatorKind, operand, methodOpt, constrainedToTypeOpt, node.OperandConversion, node.ResultConversion, node.ResultKind, node.OriginalUserDefinedOperatorsOpt, node.Type);
             }
             return updatedNode;
         }
@@ -11416,16 +11439,17 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
         public override BoundNode? VisitFunctionPointerLoad(BoundFunctionPointerLoad node)
         {
             MethodSymbol targetMethod = GetUpdatedSymbol(node, node.TargetMethod);
+            TypeSymbol? constrainedToTypeOpt = GetUpdatedSymbol(node, node.ConstrainedToTypeOpt);
             BoundFunctionPointerLoad updatedNode;
 
             if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
             {
-                updatedNode = node.Update(targetMethod, infoAndType.Type!);
+                updatedNode = node.Update(targetMethod, constrainedToTypeOpt, infoAndType.Type!);
                 updatedNode.TopLevelNullability = infoAndType.Info;
             }
             else
             {
-                updatedNode = node.Update(targetMethod, node.Type);
+                updatedNode = node.Update(targetMethod, constrainedToTypeOpt, node.Type);
             }
             return updatedNode;
         }
@@ -13716,6 +13740,7 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("operand", null, new TreeDumperNode[] { Visit(node.Operand, null) }),
             new TreeDumperNode("constantValueOpt", node.ConstantValueOpt, null),
             new TreeDumperNode("methodOpt", node.MethodOpt, null),
+            new TreeDumperNode("constrainedToTypeOpt", node.ConstrainedToTypeOpt, null),
             new TreeDumperNode("resultKind", node.ResultKind, null),
             new TreeDumperNode("originalUserDefinedOperatorsOpt", node.OriginalUserDefinedOperatorsOpt, null),
             new TreeDumperNode("type", node.Type, null),
@@ -13728,6 +13753,7 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("operatorKind", node.OperatorKind, null),
             new TreeDumperNode("operand", null, new TreeDumperNode[] { Visit(node.Operand, null) }),
             new TreeDumperNode("methodOpt", node.MethodOpt, null),
+            new TreeDumperNode("constrainedToTypeOpt", node.ConstrainedToTypeOpt, null),
             new TreeDumperNode("operandConversion", node.OperandConversion, null),
             new TreeDumperNode("resultConversion", node.ResultConversion, null),
             new TreeDumperNode("resultKind", node.ResultKind, null),
@@ -13757,6 +13783,7 @@ private BoundTreeDumperNodeProducer()
         public override TreeDumperNode VisitFunctionPointerLoad(BoundFunctionPointerLoad node, object? arg) => new TreeDumperNode("functionPointerLoad", null, new TreeDumperNode[]
         {
             new TreeDumperNode("targetMethod", node.TargetMethod, null),
+            new TreeDumperNode("constrainedToTypeOpt", node.ConstrainedToTypeOpt, null),
             new TreeDumperNode("type", node.Type, null),
             new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
             new TreeDumperNode("hasErrors", node.HasErrors, null)
@@ -13841,6 +13868,7 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("operatorKind", node.OperatorKind, null),
             new TreeDumperNode("constantValueOpt", node.ConstantValueOpt, null),
             new TreeDumperNode("methodOpt", node.MethodOpt, null),
+            new TreeDumperNode("constrainedToTypeOpt", node.ConstrainedToTypeOpt, null),
             new TreeDumperNode("resultKind", node.ResultKind, null),
             new TreeDumperNode("originalUserDefinedOperatorsOpt", node.OriginalUserDefinedOperatorsOpt, null),
             new TreeDumperNode("left", null, new TreeDumperNode[] { Visit(node.Left, null) }),
@@ -13867,6 +13895,7 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("logicalOperator", node.LogicalOperator, null),
             new TreeDumperNode("trueOperator", node.TrueOperator, null),
             new TreeDumperNode("falseOperator", node.FalseOperator, null),
+            new TreeDumperNode("constrainedToTypeOpt", node.ConstrainedToTypeOpt, null),
             new TreeDumperNode("resultKind", node.ResultKind, null),
             new TreeDumperNode("originalUserDefinedOperatorsOpt", node.OriginalUserDefinedOperatorsOpt, null),
             new TreeDumperNode("left", null, new TreeDumperNode[] { Visit(node.Left, null) }),
diff --git a/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4 b/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4
index 8fba4393903b2..9450e00d62f58 100644
--- a/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4
+++ b/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4
@@ -177,7 +177,11 @@ arrow_expression_clause
   ;
 
 conversion_operator_declaration
-  : attribute_list* modifier* ('implicit' | 'explicit') 'operator' type parameter_list (block | (arrow_expression_clause ';'))
+  : attribute_list* modifier* ('implicit' | 'explicit') explicit_interface_specifier? 'operator' type parameter_list (block | (arrow_expression_clause ';'))
+  ;
+
+explicit_interface_specifier
+  : name '.'
   ;
 
 destructor_declaration
@@ -188,10 +192,6 @@ method_declaration
   : attribute_list* modifier* type explicit_interface_specifier? identifier_token type_parameter_list? parameter_list type_parameter_constraint_clause* (block | (arrow_expression_clause ';'))
   ;
 
-explicit_interface_specifier
-  : name '.'
-  ;
-
 type_parameter_list
   : '<' type_parameter (',' type_parameter)* '>'
   ;
@@ -229,7 +229,7 @@ type_constraint
   ;
 
 operator_declaration
-  : attribute_list* modifier* type 'operator' ('+' | '-' | '!' | '~' | '++' | '--' | '*' | '/' | '%' | '<<' | '>>' | '|' | '&' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | 'false' | 'true' | 'is') parameter_list (block | (arrow_expression_clause ';'))
+  : attribute_list* modifier* type explicit_interface_specifier? 'operator' ('+' | '-' | '!' | '~' | '++' | '--' | '*' | '/' | '%' | '<<' | '>>' | '|' | '&' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | 'false' | 'true' | 'is') parameter_list (block | (arrow_expression_clause ';'))
   ;
 
 base_property_declaration
@@ -752,7 +752,7 @@ lambda_expression
   ;
 
 parenthesized_lambda_expression
-  : attribute_list* modifier* parameter_list '=>' (block | expression)
+  : attribute_list* modifier* type? parameter_list '=>' (block | expression)
   ;
 
 simple_lambda_expression
@@ -1180,7 +1180,7 @@ directive_trivia
   | end_if_directive_trivia
   | end_region_directive_trivia
   | error_directive_trivia
-  | line_directive_trivia
+  | line_or_span_directive_trivia
   | load_directive_trivia
   | nullable_directive_trivia
   | pragma_checksum_directive_trivia
@@ -1234,10 +1234,23 @@ error_directive_trivia
   : '#' 'error'
   ;
 
+line_or_span_directive_trivia
+  : line_directive_trivia
+  | line_span_directive_trivia
+  ;
+
 line_directive_trivia
   : '#' 'line' (numeric_literal_token | 'default' | 'hidden') string_literal_token?
   ;
 
+line_span_directive_trivia
+  : '#' 'line' line_directive_position '-' line_directive_position numeric_literal_token? string_literal_token
+  ;
+
+line_directive_position
+  : '(' numeric_literal_token ',' numeric_literal_token ')'
+  ;
+
 load_directive_trivia
   : '#' 'load' string_literal_token
   ;
diff --git a/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Internal.Generated.cs b/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Internal.Generated.cs
index 2abeececf176b..091928df6b8dc 100644
--- a/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Internal.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Internal.Generated.cs
@@ -6691,15 +6691,16 @@ internal sealed partial class ParenthesizedLambdaExpressionSyntax : LambdaExpres
     {
         internal readonly GreenNode? attributeLists;
         internal readonly GreenNode? modifiers;
+        internal readonly TypeSyntax? returnType;
         internal readonly ParameterListSyntax parameterList;
         internal readonly SyntaxToken arrowToken;
         internal readonly BlockSyntax? block;
         internal readonly ExpressionSyntax? expressionBody;
 
-        internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
+        internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
           : base(kind, diagnostics, annotations)
         {
-            this.SlotCount = 6;
+            this.SlotCount = 7;
             if (attributeLists != null)
             {
                 this.AdjustFlagsAndWidth(attributeLists);
@@ -6710,6 +6711,11 @@ internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attribu
                 this.AdjustFlagsAndWidth(modifiers);
                 this.modifiers = modifiers;
             }
+            if (returnType != null)
+            {
+                this.AdjustFlagsAndWidth(returnType);
+                this.returnType = returnType;
+            }
             this.AdjustFlagsAndWidth(parameterList);
             this.parameterList = parameterList;
             this.AdjustFlagsAndWidth(arrowToken);
@@ -6726,11 +6732,11 @@ internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attribu
             }
         }
 
-        internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody, SyntaxFactoryContext context)
+        internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody, SyntaxFactoryContext context)
           : base(kind)
         {
             this.SetFactoryContext(context);
-            this.SlotCount = 6;
+            this.SlotCount = 7;
             if (attributeLists != null)
             {
                 this.AdjustFlagsAndWidth(attributeLists);
@@ -6741,6 +6747,11 @@ internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attribu
                 this.AdjustFlagsAndWidth(modifiers);
                 this.modifiers = modifiers;
             }
+            if (returnType != null)
+            {
+                this.AdjustFlagsAndWidth(returnType);
+                this.returnType = returnType;
+            }
             this.AdjustFlagsAndWidth(parameterList);
             this.parameterList = parameterList;
             this.AdjustFlagsAndWidth(arrowToken);
@@ -6757,10 +6768,10 @@ internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attribu
             }
         }
 
-        internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
+        internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
           : base(kind)
         {
-            this.SlotCount = 6;
+            this.SlotCount = 7;
             if (attributeLists != null)
             {
                 this.AdjustFlagsAndWidth(attributeLists);
@@ -6771,6 +6782,11 @@ internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attribu
                 this.AdjustFlagsAndWidth(modifiers);
                 this.modifiers = modifiers;
             }
+            if (returnType != null)
+            {
+                this.AdjustFlagsAndWidth(returnType);
+                this.returnType = returnType;
+            }
             this.AdjustFlagsAndWidth(parameterList);
             this.parameterList = parameterList;
             this.AdjustFlagsAndWidth(arrowToken);
@@ -6789,6 +6805,7 @@ internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attribu
 
         public override Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> AttributeLists => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax>(this.attributeLists);
         public override Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> Modifiers => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken>(this.modifiers);
+        public TypeSyntax? ReturnType => this.returnType;
         /// <summary>ParameterListSyntax node representing the list of parameters for the lambda expression.</summary>
         public ParameterListSyntax ParameterList => this.parameterList;
         /// <summary>SyntaxToken representing equals greater than.</summary>
@@ -6809,10 +6826,11 @@ internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attribu
             {
                 0 => this.attributeLists,
                 1 => this.modifiers,
-                2 => this.parameterList,
-                3 => this.arrowToken,
-                4 => this.block,
-                5 => this.expressionBody,
+                2 => this.returnType,
+                3 => this.parameterList,
+                4 => this.arrowToken,
+                5 => this.block,
+                6 => this.expressionBody,
                 _ => null,
             };
 
@@ -6821,11 +6839,11 @@ internal ParenthesizedLambdaExpressionSyntax(SyntaxKind kind, GreenNode? attribu
         public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitParenthesizedLambdaExpression(this);
         public override TResult Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) => visitor.VisitParenthesizedLambdaExpression(this);
 
-        public ParenthesizedLambdaExpressionSyntax Update(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax block, ExpressionSyntax expressionBody)
+        public ParenthesizedLambdaExpressionSyntax Update(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax block, ExpressionSyntax expressionBody)
         {
-            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || parameterList != this.ParameterList || arrowToken != this.ArrowToken || block != this.Block || expressionBody != this.ExpressionBody)
+            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || returnType != this.ReturnType || parameterList != this.ParameterList || arrowToken != this.ArrowToken || block != this.Block || expressionBody != this.ExpressionBody)
             {
-                var newNode = SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, parameterList, arrowToken, block, expressionBody);
+                var newNode = SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, returnType, parameterList, arrowToken, block, expressionBody);
                 var diags = GetDiagnostics();
                 if (diags?.Length > 0)
                     newNode = newNode.WithDiagnosticsGreen(diags);
@@ -6839,15 +6857,15 @@ public ParenthesizedLambdaExpressionSyntax Update(Microsoft.CodeAnalysis.Syntax.
         }
 
         internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics)
-            => new ParenthesizedLambdaExpressionSyntax(this.Kind, this.attributeLists, this.modifiers, this.parameterList, this.arrowToken, this.block, this.expressionBody, diagnostics, GetAnnotations());
+            => new ParenthesizedLambdaExpressionSyntax(this.Kind, this.attributeLists, this.modifiers, this.returnType, this.parameterList, this.arrowToken, this.block, this.expressionBody, diagnostics, GetAnnotations());
 
         internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations)
-            => new ParenthesizedLambdaExpressionSyntax(this.Kind, this.attributeLists, this.modifiers, this.parameterList, this.arrowToken, this.block, this.expressionBody, GetDiagnostics(), annotations);
+            => new ParenthesizedLambdaExpressionSyntax(this.Kind, this.attributeLists, this.modifiers, this.returnType, this.parameterList, this.arrowToken, this.block, this.expressionBody, GetDiagnostics(), annotations);
 
         internal ParenthesizedLambdaExpressionSyntax(ObjectReader reader)
           : base(reader)
         {
-            this.SlotCount = 6;
+            this.SlotCount = 7;
             var attributeLists = (GreenNode?)reader.ReadValue();
             if (attributeLists != null)
             {
@@ -6860,6 +6878,12 @@ internal ParenthesizedLambdaExpressionSyntax(ObjectReader reader)
                 AdjustFlagsAndWidth(modifiers);
                 this.modifiers = modifiers;
             }
+            var returnType = (TypeSyntax?)reader.ReadValue();
+            if (returnType != null)
+            {
+                AdjustFlagsAndWidth(returnType);
+                this.returnType = returnType;
+            }
             var parameterList = (ParameterListSyntax)reader.ReadValue();
             AdjustFlagsAndWidth(parameterList);
             this.parameterList = parameterList;
@@ -6885,6 +6909,7 @@ internal override void WriteTo(ObjectWriter writer)
             base.WriteTo(writer);
             writer.WriteValue(this.attributeLists);
             writer.WriteValue(this.modifiers);
+            writer.WriteValue(this.returnType);
             writer.WriteValue(this.parameterList);
             writer.WriteValue(this.arrowToken);
             writer.WriteValue(this.block);
@@ -24450,6 +24475,7 @@ internal sealed partial class OperatorDeclarationSyntax : BaseMethodDeclarationS
         internal readonly GreenNode? attributeLists;
         internal readonly GreenNode? modifiers;
         internal readonly TypeSyntax returnType;
+        internal readonly ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier;
         internal readonly SyntaxToken operatorKeyword;
         internal readonly SyntaxToken operatorToken;
         internal readonly ParameterListSyntax parameterList;
@@ -24457,10 +24483,10 @@ internal sealed partial class OperatorDeclarationSyntax : BaseMethodDeclarationS
         internal readonly ArrowExpressionClauseSyntax? expressionBody;
         internal readonly SyntaxToken? semicolonToken;
 
-        internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
+        internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
           : base(kind, diagnostics, annotations)
         {
-            this.SlotCount = 9;
+            this.SlotCount = 10;
             if (attributeLists != null)
             {
                 this.AdjustFlagsAndWidth(attributeLists);
@@ -24473,6 +24499,11 @@ internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, G
             }
             this.AdjustFlagsAndWidth(returnType);
             this.returnType = returnType;
+            if (explicitInterfaceSpecifier != null)
+            {
+                this.AdjustFlagsAndWidth(explicitInterfaceSpecifier);
+                this.explicitInterfaceSpecifier = explicitInterfaceSpecifier;
+            }
             this.AdjustFlagsAndWidth(operatorKeyword);
             this.operatorKeyword = operatorKeyword;
             this.AdjustFlagsAndWidth(operatorToken);
@@ -24496,11 +24527,11 @@ internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, G
             }
         }
 
-        internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken, SyntaxFactoryContext context)
+        internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken, SyntaxFactoryContext context)
           : base(kind)
         {
             this.SetFactoryContext(context);
-            this.SlotCount = 9;
+            this.SlotCount = 10;
             if (attributeLists != null)
             {
                 this.AdjustFlagsAndWidth(attributeLists);
@@ -24513,6 +24544,11 @@ internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, G
             }
             this.AdjustFlagsAndWidth(returnType);
             this.returnType = returnType;
+            if (explicitInterfaceSpecifier != null)
+            {
+                this.AdjustFlagsAndWidth(explicitInterfaceSpecifier);
+                this.explicitInterfaceSpecifier = explicitInterfaceSpecifier;
+            }
             this.AdjustFlagsAndWidth(operatorKeyword);
             this.operatorKeyword = operatorKeyword;
             this.AdjustFlagsAndWidth(operatorToken);
@@ -24536,10 +24572,10 @@ internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, G
             }
         }
 
-        internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
+        internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
           : base(kind)
         {
-            this.SlotCount = 9;
+            this.SlotCount = 10;
             if (attributeLists != null)
             {
                 this.AdjustFlagsAndWidth(attributeLists);
@@ -24552,6 +24588,11 @@ internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, G
             }
             this.AdjustFlagsAndWidth(returnType);
             this.returnType = returnType;
+            if (explicitInterfaceSpecifier != null)
+            {
+                this.AdjustFlagsAndWidth(explicitInterfaceSpecifier);
+                this.explicitInterfaceSpecifier = explicitInterfaceSpecifier;
+            }
             this.AdjustFlagsAndWidth(operatorKeyword);
             this.operatorKeyword = operatorKeyword;
             this.AdjustFlagsAndWidth(operatorToken);
@@ -24579,6 +24620,7 @@ internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, G
         public override Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> Modifiers => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken>(this.modifiers);
         /// <summary>Gets the return type.</summary>
         public TypeSyntax ReturnType => this.returnType;
+        public ExplicitInterfaceSpecifierSyntax? ExplicitInterfaceSpecifier => this.explicitInterfaceSpecifier;
         /// <summary>Gets the "operator" keyword.</summary>
         public SyntaxToken OperatorKeyword => this.operatorKeyword;
         /// <summary>Gets the operator token.</summary>
@@ -24595,12 +24637,13 @@ internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, G
                 0 => this.attributeLists,
                 1 => this.modifiers,
                 2 => this.returnType,
-                3 => this.operatorKeyword,
-                4 => this.operatorToken,
-                5 => this.parameterList,
-                6 => this.body,
-                7 => this.expressionBody,
-                8 => this.semicolonToken,
+                3 => this.explicitInterfaceSpecifier,
+                4 => this.operatorKeyword,
+                5 => this.operatorToken,
+                6 => this.parameterList,
+                7 => this.body,
+                8 => this.expressionBody,
+                9 => this.semicolonToken,
                 _ => null,
             };
 
@@ -24609,11 +24652,11 @@ internal OperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, G
         public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitOperatorDeclaration(this);
         public override TResult Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) => visitor.VisitOperatorDeclaration(this);
 
-        public OperatorDeclarationSyntax Update(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
+        public OperatorDeclarationSyntax Update(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
         {
-            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || returnType != this.ReturnType || operatorKeyword != this.OperatorKeyword || operatorToken != this.OperatorToken || parameterList != this.ParameterList || body != this.Body || expressionBody != this.ExpressionBody || semicolonToken != this.SemicolonToken)
+            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || returnType != this.ReturnType || explicitInterfaceSpecifier != this.ExplicitInterfaceSpecifier || operatorKeyword != this.OperatorKeyword || operatorToken != this.OperatorToken || parameterList != this.ParameterList || body != this.Body || expressionBody != this.ExpressionBody || semicolonToken != this.SemicolonToken)
             {
-                var newNode = SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, operatorKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken);
+                var newNode = SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, operatorKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken);
                 var diags = GetDiagnostics();
                 if (diags?.Length > 0)
                     newNode = newNode.WithDiagnosticsGreen(diags);
@@ -24627,15 +24670,15 @@ public OperatorDeclarationSyntax Update(Microsoft.CodeAnalysis.Syntax.InternalSy
         }
 
         internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics)
-            => new OperatorDeclarationSyntax(this.Kind, this.attributeLists, this.modifiers, this.returnType, this.operatorKeyword, this.operatorToken, this.parameterList, this.body, this.expressionBody, this.semicolonToken, diagnostics, GetAnnotations());
+            => new OperatorDeclarationSyntax(this.Kind, this.attributeLists, this.modifiers, this.returnType, this.explicitInterfaceSpecifier, this.operatorKeyword, this.operatorToken, this.parameterList, this.body, this.expressionBody, this.semicolonToken, diagnostics, GetAnnotations());
 
         internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations)
-            => new OperatorDeclarationSyntax(this.Kind, this.attributeLists, this.modifiers, this.returnType, this.operatorKeyword, this.operatorToken, this.parameterList, this.body, this.expressionBody, this.semicolonToken, GetDiagnostics(), annotations);
+            => new OperatorDeclarationSyntax(this.Kind, this.attributeLists, this.modifiers, this.returnType, this.explicitInterfaceSpecifier, this.operatorKeyword, this.operatorToken, this.parameterList, this.body, this.expressionBody, this.semicolonToken, GetDiagnostics(), annotations);
 
         internal OperatorDeclarationSyntax(ObjectReader reader)
           : base(reader)
         {
-            this.SlotCount = 9;
+            this.SlotCount = 10;
             var attributeLists = (GreenNode?)reader.ReadValue();
             if (attributeLists != null)
             {
@@ -24651,6 +24694,12 @@ internal OperatorDeclarationSyntax(ObjectReader reader)
             var returnType = (TypeSyntax)reader.ReadValue();
             AdjustFlagsAndWidth(returnType);
             this.returnType = returnType;
+            var explicitInterfaceSpecifier = (ExplicitInterfaceSpecifierSyntax?)reader.ReadValue();
+            if (explicitInterfaceSpecifier != null)
+            {
+                AdjustFlagsAndWidth(explicitInterfaceSpecifier);
+                this.explicitInterfaceSpecifier = explicitInterfaceSpecifier;
+            }
             var operatorKeyword = (SyntaxToken)reader.ReadValue();
             AdjustFlagsAndWidth(operatorKeyword);
             this.operatorKeyword = operatorKeyword;
@@ -24686,6 +24735,7 @@ internal override void WriteTo(ObjectWriter writer)
             writer.WriteValue(this.attributeLists);
             writer.WriteValue(this.modifiers);
             writer.WriteValue(this.returnType);
+            writer.WriteValue(this.explicitInterfaceSpecifier);
             writer.WriteValue(this.operatorKeyword);
             writer.WriteValue(this.operatorToken);
             writer.WriteValue(this.parameterList);
@@ -24706,6 +24756,7 @@ internal sealed partial class ConversionOperatorDeclarationSyntax : BaseMethodDe
         internal readonly GreenNode? attributeLists;
         internal readonly GreenNode? modifiers;
         internal readonly SyntaxToken implicitOrExplicitKeyword;
+        internal readonly ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier;
         internal readonly SyntaxToken operatorKeyword;
         internal readonly TypeSyntax type;
         internal readonly ParameterListSyntax parameterList;
@@ -24713,10 +24764,10 @@ internal sealed partial class ConversionOperatorDeclarationSyntax : BaseMethodDe
         internal readonly ArrowExpressionClauseSyntax? expressionBody;
         internal readonly SyntaxToken? semicolonToken;
 
-        internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
+        internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
           : base(kind, diagnostics, annotations)
         {
-            this.SlotCount = 9;
+            this.SlotCount = 10;
             if (attributeLists != null)
             {
                 this.AdjustFlagsAndWidth(attributeLists);
@@ -24729,6 +24780,11 @@ internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attribu
             }
             this.AdjustFlagsAndWidth(implicitOrExplicitKeyword);
             this.implicitOrExplicitKeyword = implicitOrExplicitKeyword;
+            if (explicitInterfaceSpecifier != null)
+            {
+                this.AdjustFlagsAndWidth(explicitInterfaceSpecifier);
+                this.explicitInterfaceSpecifier = explicitInterfaceSpecifier;
+            }
             this.AdjustFlagsAndWidth(operatorKeyword);
             this.operatorKeyword = operatorKeyword;
             this.AdjustFlagsAndWidth(type);
@@ -24752,11 +24808,11 @@ internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attribu
             }
         }
 
-        internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken, SyntaxFactoryContext context)
+        internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken, SyntaxFactoryContext context)
           : base(kind)
         {
             this.SetFactoryContext(context);
-            this.SlotCount = 9;
+            this.SlotCount = 10;
             if (attributeLists != null)
             {
                 this.AdjustFlagsAndWidth(attributeLists);
@@ -24769,6 +24825,11 @@ internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attribu
             }
             this.AdjustFlagsAndWidth(implicitOrExplicitKeyword);
             this.implicitOrExplicitKeyword = implicitOrExplicitKeyword;
+            if (explicitInterfaceSpecifier != null)
+            {
+                this.AdjustFlagsAndWidth(explicitInterfaceSpecifier);
+                this.explicitInterfaceSpecifier = explicitInterfaceSpecifier;
+            }
             this.AdjustFlagsAndWidth(operatorKeyword);
             this.operatorKeyword = operatorKeyword;
             this.AdjustFlagsAndWidth(type);
@@ -24792,10 +24853,10 @@ internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attribu
             }
         }
 
-        internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
+        internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
           : base(kind)
         {
-            this.SlotCount = 9;
+            this.SlotCount = 10;
             if (attributeLists != null)
             {
                 this.AdjustFlagsAndWidth(attributeLists);
@@ -24808,6 +24869,11 @@ internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attribu
             }
             this.AdjustFlagsAndWidth(implicitOrExplicitKeyword);
             this.implicitOrExplicitKeyword = implicitOrExplicitKeyword;
+            if (explicitInterfaceSpecifier != null)
+            {
+                this.AdjustFlagsAndWidth(explicitInterfaceSpecifier);
+                this.explicitInterfaceSpecifier = explicitInterfaceSpecifier;
+            }
             this.AdjustFlagsAndWidth(operatorKeyword);
             this.operatorKeyword = operatorKeyword;
             this.AdjustFlagsAndWidth(type);
@@ -24835,6 +24901,7 @@ internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attribu
         public override Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> Modifiers => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken>(this.modifiers);
         /// <summary>Gets the "implicit" or "explicit" token.</summary>
         public SyntaxToken ImplicitOrExplicitKeyword => this.implicitOrExplicitKeyword;
+        public ExplicitInterfaceSpecifierSyntax? ExplicitInterfaceSpecifier => this.explicitInterfaceSpecifier;
         /// <summary>Gets the "operator" token.</summary>
         public SyntaxToken OperatorKeyword => this.operatorKeyword;
         /// <summary>Gets the type.</summary>
@@ -24851,12 +24918,13 @@ internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attribu
                 0 => this.attributeLists,
                 1 => this.modifiers,
                 2 => this.implicitOrExplicitKeyword,
-                3 => this.operatorKeyword,
-                4 => this.type,
-                5 => this.parameterList,
-                6 => this.body,
-                7 => this.expressionBody,
-                8 => this.semicolonToken,
+                3 => this.explicitInterfaceSpecifier,
+                4 => this.operatorKeyword,
+                5 => this.type,
+                6 => this.parameterList,
+                7 => this.body,
+                8 => this.expressionBody,
+                9 => this.semicolonToken,
                 _ => null,
             };
 
@@ -24865,11 +24933,11 @@ internal ConversionOperatorDeclarationSyntax(SyntaxKind kind, GreenNode? attribu
         public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitConversionOperatorDeclaration(this);
         public override TResult Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) => visitor.VisitConversionOperatorDeclaration(this);
 
-        public ConversionOperatorDeclarationSyntax Update(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
+        public ConversionOperatorDeclarationSyntax Update(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
         {
-            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || implicitOrExplicitKeyword != this.ImplicitOrExplicitKeyword || operatorKeyword != this.OperatorKeyword || type != this.Type || parameterList != this.ParameterList || body != this.Body || expressionBody != this.ExpressionBody || semicolonToken != this.SemicolonToken)
+            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || implicitOrExplicitKeyword != this.ImplicitOrExplicitKeyword || explicitInterfaceSpecifier != this.ExplicitInterfaceSpecifier || operatorKeyword != this.OperatorKeyword || type != this.Type || parameterList != this.ParameterList || body != this.Body || expressionBody != this.ExpressionBody || semicolonToken != this.SemicolonToken)
             {
-                var newNode = SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, operatorKeyword, type, parameterList, body, expressionBody, semicolonToken);
+                var newNode = SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, explicitInterfaceSpecifier, operatorKeyword, type, parameterList, body, expressionBody, semicolonToken);
                 var diags = GetDiagnostics();
                 if (diags?.Length > 0)
                     newNode = newNode.WithDiagnosticsGreen(diags);
@@ -24883,15 +24951,15 @@ public ConversionOperatorDeclarationSyntax Update(Microsoft.CodeAnalysis.Syntax.
         }
 
         internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics)
-            => new ConversionOperatorDeclarationSyntax(this.Kind, this.attributeLists, this.modifiers, this.implicitOrExplicitKeyword, this.operatorKeyword, this.type, this.parameterList, this.body, this.expressionBody, this.semicolonToken, diagnostics, GetAnnotations());
+            => new ConversionOperatorDeclarationSyntax(this.Kind, this.attributeLists, this.modifiers, this.implicitOrExplicitKeyword, this.explicitInterfaceSpecifier, this.operatorKeyword, this.type, this.parameterList, this.body, this.expressionBody, this.semicolonToken, diagnostics, GetAnnotations());
 
         internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations)
-            => new ConversionOperatorDeclarationSyntax(this.Kind, this.attributeLists, this.modifiers, this.implicitOrExplicitKeyword, this.operatorKeyword, this.type, this.parameterList, this.body, this.expressionBody, this.semicolonToken, GetDiagnostics(), annotations);
+            => new ConversionOperatorDeclarationSyntax(this.Kind, this.attributeLists, this.modifiers, this.implicitOrExplicitKeyword, this.explicitInterfaceSpecifier, this.operatorKeyword, this.type, this.parameterList, this.body, this.expressionBody, this.semicolonToken, GetDiagnostics(), annotations);
 
         internal ConversionOperatorDeclarationSyntax(ObjectReader reader)
           : base(reader)
         {
-            this.SlotCount = 9;
+            this.SlotCount = 10;
             var attributeLists = (GreenNode?)reader.ReadValue();
             if (attributeLists != null)
             {
@@ -24907,6 +24975,12 @@ internal ConversionOperatorDeclarationSyntax(ObjectReader reader)
             var implicitOrExplicitKeyword = (SyntaxToken)reader.ReadValue();
             AdjustFlagsAndWidth(implicitOrExplicitKeyword);
             this.implicitOrExplicitKeyword = implicitOrExplicitKeyword;
+            var explicitInterfaceSpecifier = (ExplicitInterfaceSpecifierSyntax?)reader.ReadValue();
+            if (explicitInterfaceSpecifier != null)
+            {
+                AdjustFlagsAndWidth(explicitInterfaceSpecifier);
+                this.explicitInterfaceSpecifier = explicitInterfaceSpecifier;
+            }
             var operatorKeyword = (SyntaxToken)reader.ReadValue();
             AdjustFlagsAndWidth(operatorKeyword);
             this.operatorKeyword = operatorKeyword;
@@ -24942,6 +25016,7 @@ internal override void WriteTo(ObjectWriter writer)
             writer.WriteValue(this.attributeLists);
             writer.WriteValue(this.modifiers);
             writer.WriteValue(this.implicitOrExplicitKeyword);
+            writer.WriteValue(this.explicitInterfaceSpecifier);
             writer.WriteValue(this.operatorKeyword);
             writer.WriteValue(this.type);
             writer.WriteValue(this.parameterList);
@@ -32133,7 +32208,29 @@ static UndefDirectiveTriviaSyntax()
         }
     }
 
-    internal sealed partial class LineDirectiveTriviaSyntax : DirectiveTriviaSyntax
+    internal abstract partial class LineOrSpanDirectiveTriviaSyntax : DirectiveTriviaSyntax
+    {
+        internal LineOrSpanDirectiveTriviaSyntax(SyntaxKind kind, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
+          : base(kind, diagnostics, annotations)
+        {
+        }
+
+        internal LineOrSpanDirectiveTriviaSyntax(SyntaxKind kind)
+          : base(kind)
+        {
+        }
+
+        protected LineOrSpanDirectiveTriviaSyntax(ObjectReader reader)
+          : base(reader)
+        {
+        }
+
+        public abstract SyntaxToken LineKeyword { get; }
+
+        public abstract SyntaxToken? File { get; }
+    }
+
+    internal sealed partial class LineDirectiveTriviaSyntax : LineOrSpanDirectiveTriviaSyntax
     {
         internal readonly SyntaxToken hashToken;
         internal readonly SyntaxToken lineKeyword;
@@ -32204,9 +32301,9 @@ internal LineDirectiveTriviaSyntax(SyntaxKind kind, SyntaxToken hashToken, Synta
         }
 
         public override SyntaxToken HashToken => this.hashToken;
-        public SyntaxToken LineKeyword => this.lineKeyword;
+        public override SyntaxToken LineKeyword => this.lineKeyword;
         public SyntaxToken Line => this.line;
-        public SyntaxToken? File => this.file;
+        public override SyntaxToken? File => this.file;
         public override SyntaxToken EndOfDirectiveToken => this.endOfDirectiveToken;
         public override bool IsActive => this.isActive;
 
@@ -32291,6 +32388,342 @@ static LineDirectiveTriviaSyntax()
         }
     }
 
+    internal sealed partial class LineDirectivePositionSyntax : CSharpSyntaxNode
+    {
+        internal readonly SyntaxToken openParenToken;
+        internal readonly SyntaxToken line;
+        internal readonly SyntaxToken commaToken;
+        internal readonly SyntaxToken character;
+        internal readonly SyntaxToken closeParenToken;
+
+        internal LineDirectivePositionSyntax(SyntaxKind kind, SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
+          : base(kind, diagnostics, annotations)
+        {
+            this.SlotCount = 5;
+            this.AdjustFlagsAndWidth(openParenToken);
+            this.openParenToken = openParenToken;
+            this.AdjustFlagsAndWidth(line);
+            this.line = line;
+            this.AdjustFlagsAndWidth(commaToken);
+            this.commaToken = commaToken;
+            this.AdjustFlagsAndWidth(character);
+            this.character = character;
+            this.AdjustFlagsAndWidth(closeParenToken);
+            this.closeParenToken = closeParenToken;
+        }
+
+        internal LineDirectivePositionSyntax(SyntaxKind kind, SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken, SyntaxFactoryContext context)
+          : base(kind)
+        {
+            this.SetFactoryContext(context);
+            this.SlotCount = 5;
+            this.AdjustFlagsAndWidth(openParenToken);
+            this.openParenToken = openParenToken;
+            this.AdjustFlagsAndWidth(line);
+            this.line = line;
+            this.AdjustFlagsAndWidth(commaToken);
+            this.commaToken = commaToken;
+            this.AdjustFlagsAndWidth(character);
+            this.character = character;
+            this.AdjustFlagsAndWidth(closeParenToken);
+            this.closeParenToken = closeParenToken;
+        }
+
+        internal LineDirectivePositionSyntax(SyntaxKind kind, SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken)
+          : base(kind)
+        {
+            this.SlotCount = 5;
+            this.AdjustFlagsAndWidth(openParenToken);
+            this.openParenToken = openParenToken;
+            this.AdjustFlagsAndWidth(line);
+            this.line = line;
+            this.AdjustFlagsAndWidth(commaToken);
+            this.commaToken = commaToken;
+            this.AdjustFlagsAndWidth(character);
+            this.character = character;
+            this.AdjustFlagsAndWidth(closeParenToken);
+            this.closeParenToken = closeParenToken;
+        }
+
+        public SyntaxToken OpenParenToken => this.openParenToken;
+        public SyntaxToken Line => this.line;
+        public SyntaxToken CommaToken => this.commaToken;
+        public SyntaxToken Character => this.character;
+        public SyntaxToken CloseParenToken => this.closeParenToken;
+
+        internal override GreenNode? GetSlot(int index)
+            => index switch
+            {
+                0 => this.openParenToken,
+                1 => this.line,
+                2 => this.commaToken,
+                3 => this.character,
+                4 => this.closeParenToken,
+                _ => null,
+            };
+
+        internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.LineDirectivePositionSyntax(this, parent, position);
+
+        public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitLineDirectivePosition(this);
+        public override TResult Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) => visitor.VisitLineDirectivePosition(this);
+
+        public LineDirectivePositionSyntax Update(SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken)
+        {
+            if (openParenToken != this.OpenParenToken || line != this.Line || commaToken != this.CommaToken || character != this.Character || closeParenToken != this.CloseParenToken)
+            {
+                var newNode = SyntaxFactory.LineDirectivePosition(openParenToken, line, commaToken, character, closeParenToken);
+                var diags = GetDiagnostics();
+                if (diags?.Length > 0)
+                    newNode = newNode.WithDiagnosticsGreen(diags);
+                var annotations = GetAnnotations();
+                if (annotations?.Length > 0)
+                    newNode = newNode.WithAnnotationsGreen(annotations);
+                return newNode;
+            }
+
+            return this;
+        }
+
+        internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics)
+            => new LineDirectivePositionSyntax(this.Kind, this.openParenToken, this.line, this.commaToken, this.character, this.closeParenToken, diagnostics, GetAnnotations());
+
+        internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations)
+            => new LineDirectivePositionSyntax(this.Kind, this.openParenToken, this.line, this.commaToken, this.character, this.closeParenToken, GetDiagnostics(), annotations);
+
+        internal LineDirectivePositionSyntax(ObjectReader reader)
+          : base(reader)
+        {
+            this.SlotCount = 5;
+            var openParenToken = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(openParenToken);
+            this.openParenToken = openParenToken;
+            var line = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(line);
+            this.line = line;
+            var commaToken = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(commaToken);
+            this.commaToken = commaToken;
+            var character = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(character);
+            this.character = character;
+            var closeParenToken = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(closeParenToken);
+            this.closeParenToken = closeParenToken;
+        }
+
+        internal override void WriteTo(ObjectWriter writer)
+        {
+            base.WriteTo(writer);
+            writer.WriteValue(this.openParenToken);
+            writer.WriteValue(this.line);
+            writer.WriteValue(this.commaToken);
+            writer.WriteValue(this.character);
+            writer.WriteValue(this.closeParenToken);
+        }
+
+        static LineDirectivePositionSyntax()
+        {
+            ObjectBinder.RegisterTypeReader(typeof(LineDirectivePositionSyntax), r => new LineDirectivePositionSyntax(r));
+        }
+    }
+
+    internal sealed partial class LineSpanDirectiveTriviaSyntax : LineOrSpanDirectiveTriviaSyntax
+    {
+        internal readonly SyntaxToken hashToken;
+        internal readonly SyntaxToken lineKeyword;
+        internal readonly LineDirectivePositionSyntax start;
+        internal readonly SyntaxToken minusToken;
+        internal readonly LineDirectivePositionSyntax end;
+        internal readonly SyntaxToken? characterOffset;
+        internal readonly SyntaxToken file;
+        internal readonly SyntaxToken endOfDirectiveToken;
+        internal readonly bool isActive;
+
+        internal LineSpanDirectiveTriviaSyntax(SyntaxKind kind, SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken? characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations)
+          : base(kind, diagnostics, annotations)
+        {
+            this.SlotCount = 8;
+            this.AdjustFlagsAndWidth(hashToken);
+            this.hashToken = hashToken;
+            this.AdjustFlagsAndWidth(lineKeyword);
+            this.lineKeyword = lineKeyword;
+            this.AdjustFlagsAndWidth(start);
+            this.start = start;
+            this.AdjustFlagsAndWidth(minusToken);
+            this.minusToken = minusToken;
+            this.AdjustFlagsAndWidth(end);
+            this.end = end;
+            if (characterOffset != null)
+            {
+                this.AdjustFlagsAndWidth(characterOffset);
+                this.characterOffset = characterOffset;
+            }
+            this.AdjustFlagsAndWidth(file);
+            this.file = file;
+            this.AdjustFlagsAndWidth(endOfDirectiveToken);
+            this.endOfDirectiveToken = endOfDirectiveToken;
+            this.isActive = isActive;
+        }
+
+        internal LineSpanDirectiveTriviaSyntax(SyntaxKind kind, SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken? characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive, SyntaxFactoryContext context)
+          : base(kind)
+        {
+            this.SetFactoryContext(context);
+            this.SlotCount = 8;
+            this.AdjustFlagsAndWidth(hashToken);
+            this.hashToken = hashToken;
+            this.AdjustFlagsAndWidth(lineKeyword);
+            this.lineKeyword = lineKeyword;
+            this.AdjustFlagsAndWidth(start);
+            this.start = start;
+            this.AdjustFlagsAndWidth(minusToken);
+            this.minusToken = minusToken;
+            this.AdjustFlagsAndWidth(end);
+            this.end = end;
+            if (characterOffset != null)
+            {
+                this.AdjustFlagsAndWidth(characterOffset);
+                this.characterOffset = characterOffset;
+            }
+            this.AdjustFlagsAndWidth(file);
+            this.file = file;
+            this.AdjustFlagsAndWidth(endOfDirectiveToken);
+            this.endOfDirectiveToken = endOfDirectiveToken;
+            this.isActive = isActive;
+        }
+
+        internal LineSpanDirectiveTriviaSyntax(SyntaxKind kind, SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken? characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
+          : base(kind)
+        {
+            this.SlotCount = 8;
+            this.AdjustFlagsAndWidth(hashToken);
+            this.hashToken = hashToken;
+            this.AdjustFlagsAndWidth(lineKeyword);
+            this.lineKeyword = lineKeyword;
+            this.AdjustFlagsAndWidth(start);
+            this.start = start;
+            this.AdjustFlagsAndWidth(minusToken);
+            this.minusToken = minusToken;
+            this.AdjustFlagsAndWidth(end);
+            this.end = end;
+            if (characterOffset != null)
+            {
+                this.AdjustFlagsAndWidth(characterOffset);
+                this.characterOffset = characterOffset;
+            }
+            this.AdjustFlagsAndWidth(file);
+            this.file = file;
+            this.AdjustFlagsAndWidth(endOfDirectiveToken);
+            this.endOfDirectiveToken = endOfDirectiveToken;
+            this.isActive = isActive;
+        }
+
+        public override SyntaxToken HashToken => this.hashToken;
+        public override SyntaxToken LineKeyword => this.lineKeyword;
+        public LineDirectivePositionSyntax Start => this.start;
+        public SyntaxToken MinusToken => this.minusToken;
+        public LineDirectivePositionSyntax End => this.end;
+        public SyntaxToken? CharacterOffset => this.characterOffset;
+        public override SyntaxToken File => this.file;
+        public override SyntaxToken EndOfDirectiveToken => this.endOfDirectiveToken;
+        public override bool IsActive => this.isActive;
+
+        internal override GreenNode? GetSlot(int index)
+            => index switch
+            {
+                0 => this.hashToken,
+                1 => this.lineKeyword,
+                2 => this.start,
+                3 => this.minusToken,
+                4 => this.end,
+                5 => this.characterOffset,
+                6 => this.file,
+                7 => this.endOfDirectiveToken,
+                _ => null,
+            };
+
+        internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.LineSpanDirectiveTriviaSyntax(this, parent, position);
+
+        public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitLineSpanDirectiveTrivia(this);
+        public override TResult Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) => visitor.VisitLineSpanDirectiveTrivia(this);
+
+        public LineSpanDirectiveTriviaSyntax Update(SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
+        {
+            if (hashToken != this.HashToken || lineKeyword != this.LineKeyword || start != this.Start || minusToken != this.MinusToken || end != this.End || characterOffset != this.CharacterOffset || file != this.File || endOfDirectiveToken != this.EndOfDirectiveToken)
+            {
+                var newNode = SyntaxFactory.LineSpanDirectiveTrivia(hashToken, lineKeyword, start, minusToken, end, characterOffset, file, endOfDirectiveToken, isActive);
+                var diags = GetDiagnostics();
+                if (diags?.Length > 0)
+                    newNode = newNode.WithDiagnosticsGreen(diags);
+                var annotations = GetAnnotations();
+                if (annotations?.Length > 0)
+                    newNode = newNode.WithAnnotationsGreen(annotations);
+                return newNode;
+            }
+
+            return this;
+        }
+
+        internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics)
+            => new LineSpanDirectiveTriviaSyntax(this.Kind, this.hashToken, this.lineKeyword, this.start, this.minusToken, this.end, this.characterOffset, this.file, this.endOfDirectiveToken, this.isActive, diagnostics, GetAnnotations());
+
+        internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations)
+            => new LineSpanDirectiveTriviaSyntax(this.Kind, this.hashToken, this.lineKeyword, this.start, this.minusToken, this.end, this.characterOffset, this.file, this.endOfDirectiveToken, this.isActive, GetDiagnostics(), annotations);
+
+        internal LineSpanDirectiveTriviaSyntax(ObjectReader reader)
+          : base(reader)
+        {
+            this.SlotCount = 8;
+            var hashToken = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(hashToken);
+            this.hashToken = hashToken;
+            var lineKeyword = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(lineKeyword);
+            this.lineKeyword = lineKeyword;
+            var start = (LineDirectivePositionSyntax)reader.ReadValue();
+            AdjustFlagsAndWidth(start);
+            this.start = start;
+            var minusToken = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(minusToken);
+            this.minusToken = minusToken;
+            var end = (LineDirectivePositionSyntax)reader.ReadValue();
+            AdjustFlagsAndWidth(end);
+            this.end = end;
+            var characterOffset = (SyntaxToken?)reader.ReadValue();
+            if (characterOffset != null)
+            {
+                AdjustFlagsAndWidth(characterOffset);
+                this.characterOffset = characterOffset;
+            }
+            var file = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(file);
+            this.file = file;
+            var endOfDirectiveToken = (SyntaxToken)reader.ReadValue();
+            AdjustFlagsAndWidth(endOfDirectiveToken);
+            this.endOfDirectiveToken = endOfDirectiveToken;
+            this.isActive = (bool)reader.ReadBoolean();
+        }
+
+        internal override void WriteTo(ObjectWriter writer)
+        {
+            base.WriteTo(writer);
+            writer.WriteValue(this.hashToken);
+            writer.WriteValue(this.lineKeyword);
+            writer.WriteValue(this.start);
+            writer.WriteValue(this.minusToken);
+            writer.WriteValue(this.end);
+            writer.WriteValue(this.characterOffset);
+            writer.WriteValue(this.file);
+            writer.WriteValue(this.endOfDirectiveToken);
+            writer.WriteBoolean(this.isActive);
+        }
+
+        static LineSpanDirectiveTriviaSyntax()
+        {
+            ObjectBinder.RegisterTypeReader(typeof(LineSpanDirectiveTriviaSyntax), r => new LineSpanDirectiveTriviaSyntax(r));
+        }
+    }
+
     internal sealed partial class PragmaWarningDirectiveTriviaSyntax : DirectiveTriviaSyntax
     {
         internal readonly SyntaxToken hashToken;
@@ -33406,6 +33839,8 @@ internal partial class CSharpSyntaxVisitor<TResult>
         public virtual TResult VisitDefineDirectiveTrivia(DefineDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual TResult VisitUndefDirectiveTrivia(UndefDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual TResult VisitLineDirectiveTrivia(LineDirectiveTriviaSyntax node) => this.DefaultVisit(node);
+        public virtual TResult VisitLineDirectivePosition(LineDirectivePositionSyntax node) => this.DefaultVisit(node);
+        public virtual TResult VisitLineSpanDirectiveTrivia(LineSpanDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual TResult VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual TResult VisitPragmaChecksumDirectiveTrivia(PragmaChecksumDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual TResult VisitReferenceDirectiveTrivia(ReferenceDirectiveTriviaSyntax node) => this.DefaultVisit(node);
@@ -33642,6 +34077,8 @@ internal partial class CSharpSyntaxVisitor
         public virtual void VisitDefineDirectiveTrivia(DefineDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual void VisitUndefDirectiveTrivia(UndefDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual void VisitLineDirectiveTrivia(LineDirectiveTriviaSyntax node) => this.DefaultVisit(node);
+        public virtual void VisitLineDirectivePosition(LineDirectivePositionSyntax node) => this.DefaultVisit(node);
+        public virtual void VisitLineSpanDirectiveTrivia(LineSpanDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual void VisitPragmaChecksumDirectiveTrivia(PragmaChecksumDirectiveTriviaSyntax node) => this.DefaultVisit(node);
         public virtual void VisitReferenceDirectiveTrivia(ReferenceDirectiveTriviaSyntax node) => this.DefaultVisit(node);
@@ -33818,7 +34255,7 @@ public override CSharpSyntaxNode VisitRefExpression(RefExpressionSyntax node)
             => node.Update((SyntaxToken)Visit(node.RefKeyword), (ExpressionSyntax)Visit(node.Expression));
 
         public override CSharpSyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node)
-            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (ParameterListSyntax)Visit(node.ParameterList), (SyntaxToken)Visit(node.ArrowToken), (BlockSyntax)Visit(node.Block), (ExpressionSyntax)Visit(node.ExpressionBody));
+            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax)Visit(node.ReturnType), (ParameterListSyntax)Visit(node.ParameterList), (SyntaxToken)Visit(node.ArrowToken), (BlockSyntax)Visit(node.Block), (ExpressionSyntax)Visit(node.ExpressionBody));
 
         public override CSharpSyntaxNode VisitInitializerExpression(InitializerExpressionSyntax node)
             => node.Update((SyntaxToken)Visit(node.OpenBraceToken), VisitList(node.Expressions), (SyntaxToken)Visit(node.CloseBraceToken));
@@ -34175,10 +34612,10 @@ public override CSharpSyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax
             => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax)Visit(node.ReturnType), (ExplicitInterfaceSpecifierSyntax)Visit(node.ExplicitInterfaceSpecifier), (SyntaxToken)Visit(node.Identifier), (TypeParameterListSyntax)Visit(node.TypeParameterList), (ParameterListSyntax)Visit(node.ParameterList), VisitList(node.ConstraintClauses), (BlockSyntax)Visit(node.Body), (ArrowExpressionClauseSyntax)Visit(node.ExpressionBody), (SyntaxToken)Visit(node.SemicolonToken));
 
         public override CSharpSyntaxNode VisitOperatorDeclaration(OperatorDeclarationSyntax node)
-            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax)Visit(node.ReturnType), (SyntaxToken)Visit(node.OperatorKeyword), (SyntaxToken)Visit(node.OperatorToken), (ParameterListSyntax)Visit(node.ParameterList), (BlockSyntax)Visit(node.Body), (ArrowExpressionClauseSyntax)Visit(node.ExpressionBody), (SyntaxToken)Visit(node.SemicolonToken));
+            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax)Visit(node.ReturnType), (ExplicitInterfaceSpecifierSyntax)Visit(node.ExplicitInterfaceSpecifier), (SyntaxToken)Visit(node.OperatorKeyword), (SyntaxToken)Visit(node.OperatorToken), (ParameterListSyntax)Visit(node.ParameterList), (BlockSyntax)Visit(node.Body), (ArrowExpressionClauseSyntax)Visit(node.ExpressionBody), (SyntaxToken)Visit(node.SemicolonToken));
 
         public override CSharpSyntaxNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node)
-            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (SyntaxToken)Visit(node.ImplicitOrExplicitKeyword), (SyntaxToken)Visit(node.OperatorKeyword), (TypeSyntax)Visit(node.Type), (ParameterListSyntax)Visit(node.ParameterList), (BlockSyntax)Visit(node.Body), (ArrowExpressionClauseSyntax)Visit(node.ExpressionBody), (SyntaxToken)Visit(node.SemicolonToken));
+            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (SyntaxToken)Visit(node.ImplicitOrExplicitKeyword), (ExplicitInterfaceSpecifierSyntax)Visit(node.ExplicitInterfaceSpecifier), (SyntaxToken)Visit(node.OperatorKeyword), (TypeSyntax)Visit(node.Type), (ParameterListSyntax)Visit(node.ParameterList), (BlockSyntax)Visit(node.Body), (ArrowExpressionClauseSyntax)Visit(node.ExpressionBody), (SyntaxToken)Visit(node.SemicolonToken));
 
         public override CSharpSyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
             => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (SyntaxToken)Visit(node.Identifier), (ParameterListSyntax)Visit(node.ParameterList), (ConstructorInitializerSyntax)Visit(node.Initializer), (BlockSyntax)Visit(node.Body), (ArrowExpressionClauseSyntax)Visit(node.ExpressionBody), (SyntaxToken)Visit(node.SemicolonToken));
@@ -34330,6 +34767,12 @@ public override CSharpSyntaxNode VisitUndefDirectiveTrivia(UndefDirectiveTriviaS
         public override CSharpSyntaxNode VisitLineDirectiveTrivia(LineDirectiveTriviaSyntax node)
             => node.Update((SyntaxToken)Visit(node.HashToken), (SyntaxToken)Visit(node.LineKeyword), (SyntaxToken)Visit(node.Line), (SyntaxToken)Visit(node.File), (SyntaxToken)Visit(node.EndOfDirectiveToken), node.IsActive);
 
+        public override CSharpSyntaxNode VisitLineDirectivePosition(LineDirectivePositionSyntax node)
+            => node.Update((SyntaxToken)Visit(node.OpenParenToken), (SyntaxToken)Visit(node.Line), (SyntaxToken)Visit(node.CommaToken), (SyntaxToken)Visit(node.Character), (SyntaxToken)Visit(node.CloseParenToken));
+
+        public override CSharpSyntaxNode VisitLineSpanDirectiveTrivia(LineSpanDirectiveTriviaSyntax node)
+            => node.Update((SyntaxToken)Visit(node.HashToken), (SyntaxToken)Visit(node.LineKeyword), (LineDirectivePositionSyntax)Visit(node.Start), (SyntaxToken)Visit(node.MinusToken), (LineDirectivePositionSyntax)Visit(node.End), (SyntaxToken)Visit(node.CharacterOffset), (SyntaxToken)Visit(node.File), (SyntaxToken)Visit(node.EndOfDirectiveToken), node.IsActive);
+
         public override CSharpSyntaxNode VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
             => node.Update((SyntaxToken)Visit(node.HashToken), (SyntaxToken)Visit(node.PragmaKeyword), (SyntaxToken)Visit(node.WarningKeyword), (SyntaxToken)Visit(node.DisableOrRestoreKeyword), VisitList(node.ErrorCodes), (SyntaxToken)Visit(node.EndOfDirectiveToken), node.IsActive);
 
@@ -35645,7 +36088,7 @@ public RefExpressionSyntax RefExpression(SyntaxToken refKeyword, ExpressionSynta
             return result;
         }
 
-        public ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
+        public ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
         {
 #if DEBUG
             if (parameterList == null) throw new ArgumentNullException(nameof(parameterList));
@@ -35653,7 +36096,7 @@ public ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(Microso
             if (arrowToken.Kind != SyntaxKind.EqualsGreaterThanToken) throw new ArgumentException(nameof(arrowToken));
 #endif
 
-            return new ParenthesizedLambdaExpressionSyntax(SyntaxKind.ParenthesizedLambdaExpression, attributeLists.Node, modifiers.Node, parameterList, arrowToken, block, expressionBody, this.context);
+            return new ParenthesizedLambdaExpressionSyntax(SyntaxKind.ParenthesizedLambdaExpression, attributeLists.Node, modifiers.Node, returnType, parameterList, arrowToken, block, expressionBody, this.context);
         }
 
         public InitializerExpressionSyntax InitializerExpression(SyntaxKind kind, SyntaxToken openBraceToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList<ExpressionSyntax> expressions, SyntaxToken closeBraceToken)
@@ -38064,7 +38507,7 @@ public MethodDeclarationSyntax MethodDeclaration(Microsoft.CodeAnalysis.Syntax.I
             return new MethodDeclarationSyntax(SyntaxKind.MethodDeclaration, attributeLists.Node, modifiers.Node, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses.Node, body, expressionBody, semicolonToken, this.context);
         }
 
-        public OperatorDeclarationSyntax OperatorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
+        public OperatorDeclarationSyntax OperatorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
         {
 #if DEBUG
             if (returnType == null) throw new ArgumentNullException(nameof(returnType));
@@ -38110,10 +38553,10 @@ public OperatorDeclarationSyntax OperatorDeclaration(Microsoft.CodeAnalysis.Synt
             }
 #endif
 
-            return new OperatorDeclarationSyntax(SyntaxKind.OperatorDeclaration, attributeLists.Node, modifiers.Node, returnType, operatorKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken, this.context);
+            return new OperatorDeclarationSyntax(SyntaxKind.OperatorDeclaration, attributeLists.Node, modifiers.Node, returnType, explicitInterfaceSpecifier, operatorKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken, this.context);
         }
 
-        public ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
+        public ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
         {
 #if DEBUG
             if (implicitOrExplicitKeyword == null) throw new ArgumentNullException(nameof(implicitOrExplicitKeyword));
@@ -38138,7 +38581,7 @@ public ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(Microso
             }
 #endif
 
-            return new ConversionOperatorDeclarationSyntax(SyntaxKind.ConversionOperatorDeclaration, attributeLists.Node, modifiers.Node, implicitOrExplicitKeyword, operatorKeyword, type, parameterList, body, expressionBody, semicolonToken, this.context);
+            return new ConversionOperatorDeclarationSyntax(SyntaxKind.ConversionOperatorDeclaration, attributeLists.Node, modifiers.Node, implicitOrExplicitKeyword, explicitInterfaceSpecifier, operatorKeyword, type, parameterList, body, expressionBody, semicolonToken, this.context);
         }
 
         public ConstructorDeclarationSyntax ConstructorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, SyntaxToken identifier, ParameterListSyntax parameterList, ConstructorInitializerSyntax? initializer, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
@@ -39143,6 +39586,53 @@ public LineDirectiveTriviaSyntax LineDirectiveTrivia(SyntaxToken hashToken, Synt
             return new LineDirectiveTriviaSyntax(SyntaxKind.LineDirectiveTrivia, hashToken, lineKeyword, line, file, endOfDirectiveToken, isActive, this.context);
         }
 
+        public LineDirectivePositionSyntax LineDirectivePosition(SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken)
+        {
+#if DEBUG
+            if (openParenToken == null) throw new ArgumentNullException(nameof(openParenToken));
+            if (openParenToken.Kind != SyntaxKind.OpenParenToken) throw new ArgumentException(nameof(openParenToken));
+            if (line == null) throw new ArgumentNullException(nameof(line));
+            if (line.Kind != SyntaxKind.NumericLiteralToken) throw new ArgumentException(nameof(line));
+            if (commaToken == null) throw new ArgumentNullException(nameof(commaToken));
+            if (commaToken.Kind != SyntaxKind.CommaToken) throw new ArgumentException(nameof(commaToken));
+            if (character == null) throw new ArgumentNullException(nameof(character));
+            if (character.Kind != SyntaxKind.NumericLiteralToken) throw new ArgumentException(nameof(character));
+            if (closeParenToken == null) throw new ArgumentNullException(nameof(closeParenToken));
+            if (closeParenToken.Kind != SyntaxKind.CloseParenToken) throw new ArgumentException(nameof(closeParenToken));
+#endif
+
+            return new LineDirectivePositionSyntax(SyntaxKind.LineDirectivePosition, openParenToken, line, commaToken, character, closeParenToken, this.context);
+        }
+
+        public LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken? characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
+        {
+#if DEBUG
+            if (hashToken == null) throw new ArgumentNullException(nameof(hashToken));
+            if (hashToken.Kind != SyntaxKind.HashToken) throw new ArgumentException(nameof(hashToken));
+            if (lineKeyword == null) throw new ArgumentNullException(nameof(lineKeyword));
+            if (lineKeyword.Kind != SyntaxKind.LineKeyword) throw new ArgumentException(nameof(lineKeyword));
+            if (start == null) throw new ArgumentNullException(nameof(start));
+            if (minusToken == null) throw new ArgumentNullException(nameof(minusToken));
+            if (minusToken.Kind != SyntaxKind.MinusToken) throw new ArgumentException(nameof(minusToken));
+            if (end == null) throw new ArgumentNullException(nameof(end));
+            if (characterOffset != null)
+            {
+                switch (characterOffset.Kind)
+                {
+                    case SyntaxKind.NumericLiteralToken:
+                    case SyntaxKind.None: break;
+                    default: throw new ArgumentException(nameof(characterOffset));
+                }
+            }
+            if (file == null) throw new ArgumentNullException(nameof(file));
+            if (file.Kind != SyntaxKind.StringLiteralToken) throw new ArgumentException(nameof(file));
+            if (endOfDirectiveToken == null) throw new ArgumentNullException(nameof(endOfDirectiveToken));
+            if (endOfDirectiveToken.Kind != SyntaxKind.EndOfDirectiveToken) throw new ArgumentException(nameof(endOfDirectiveToken));
+#endif
+
+            return new LineSpanDirectiveTriviaSyntax(SyntaxKind.LineSpanDirectiveTrivia, hashToken, lineKeyword, start, minusToken, end, characterOffset, file, endOfDirectiveToken, isActive, this.context);
+        }
+
         public PragmaWarningDirectiveTriviaSyntax PragmaWarningDirectiveTrivia(SyntaxToken hashToken, SyntaxToken pragmaKeyword, SyntaxToken warningKeyword, SyntaxToken disableOrRestoreKeyword, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList<ExpressionSyntax> errorCodes, SyntaxToken endOfDirectiveToken, bool isActive)
         {
 #if DEBUG
@@ -40558,7 +41048,7 @@ public static RefExpressionSyntax RefExpression(SyntaxToken refKeyword, Expressi
             return result;
         }
 
-        public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
+        public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
         {
 #if DEBUG
             if (parameterList == null) throw new ArgumentNullException(nameof(parameterList));
@@ -40566,7 +41056,7 @@ public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(
             if (arrowToken.Kind != SyntaxKind.EqualsGreaterThanToken) throw new ArgumentException(nameof(arrowToken));
 #endif
 
-            return new ParenthesizedLambdaExpressionSyntax(SyntaxKind.ParenthesizedLambdaExpression, attributeLists.Node, modifiers.Node, parameterList, arrowToken, block, expressionBody);
+            return new ParenthesizedLambdaExpressionSyntax(SyntaxKind.ParenthesizedLambdaExpression, attributeLists.Node, modifiers.Node, returnType, parameterList, arrowToken, block, expressionBody);
         }
 
         public static InitializerExpressionSyntax InitializerExpression(SyntaxKind kind, SyntaxToken openBraceToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList<ExpressionSyntax> expressions, SyntaxToken closeBraceToken)
@@ -42977,7 +43467,7 @@ public static MethodDeclarationSyntax MethodDeclaration(Microsoft.CodeAnalysis.S
             return new MethodDeclarationSyntax(SyntaxKind.MethodDeclaration, attributeLists.Node, modifiers.Node, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses.Node, body, expressionBody, semicolonToken);
         }
 
-        public static OperatorDeclarationSyntax OperatorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
+        public static OperatorDeclarationSyntax OperatorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
         {
 #if DEBUG
             if (returnType == null) throw new ArgumentNullException(nameof(returnType));
@@ -43023,10 +43513,10 @@ public static OperatorDeclarationSyntax OperatorDeclaration(Microsoft.CodeAnalys
             }
 #endif
 
-            return new OperatorDeclarationSyntax(SyntaxKind.OperatorDeclaration, attributeLists.Node, modifiers.Node, returnType, operatorKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken);
+            return new OperatorDeclarationSyntax(SyntaxKind.OperatorDeclaration, attributeLists.Node, modifiers.Node, returnType, explicitInterfaceSpecifier, operatorKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken);
         }
 
-        public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
+        public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
         {
 #if DEBUG
             if (implicitOrExplicitKeyword == null) throw new ArgumentNullException(nameof(implicitOrExplicitKeyword));
@@ -43051,7 +43541,7 @@ public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(
             }
 #endif
 
-            return new ConversionOperatorDeclarationSyntax(SyntaxKind.ConversionOperatorDeclaration, attributeLists.Node, modifiers.Node, implicitOrExplicitKeyword, operatorKeyword, type, parameterList, body, expressionBody, semicolonToken);
+            return new ConversionOperatorDeclarationSyntax(SyntaxKind.ConversionOperatorDeclaration, attributeLists.Node, modifiers.Node, implicitOrExplicitKeyword, explicitInterfaceSpecifier, operatorKeyword, type, parameterList, body, expressionBody, semicolonToken);
         }
 
         public static ConstructorDeclarationSyntax ConstructorDeclaration(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, SyntaxToken identifier, ParameterListSyntax parameterList, ConstructorInitializerSyntax? initializer, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken)
@@ -44056,6 +44546,53 @@ public static LineDirectiveTriviaSyntax LineDirectiveTrivia(SyntaxToken hashToke
             return new LineDirectiveTriviaSyntax(SyntaxKind.LineDirectiveTrivia, hashToken, lineKeyword, line, file, endOfDirectiveToken, isActive);
         }
 
+        public static LineDirectivePositionSyntax LineDirectivePosition(SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken)
+        {
+#if DEBUG
+            if (openParenToken == null) throw new ArgumentNullException(nameof(openParenToken));
+            if (openParenToken.Kind != SyntaxKind.OpenParenToken) throw new ArgumentException(nameof(openParenToken));
+            if (line == null) throw new ArgumentNullException(nameof(line));
+            if (line.Kind != SyntaxKind.NumericLiteralToken) throw new ArgumentException(nameof(line));
+            if (commaToken == null) throw new ArgumentNullException(nameof(commaToken));
+            if (commaToken.Kind != SyntaxKind.CommaToken) throw new ArgumentException(nameof(commaToken));
+            if (character == null) throw new ArgumentNullException(nameof(character));
+            if (character.Kind != SyntaxKind.NumericLiteralToken) throw new ArgumentException(nameof(character));
+            if (closeParenToken == null) throw new ArgumentNullException(nameof(closeParenToken));
+            if (closeParenToken.Kind != SyntaxKind.CloseParenToken) throw new ArgumentException(nameof(closeParenToken));
+#endif
+
+            return new LineDirectivePositionSyntax(SyntaxKind.LineDirectivePosition, openParenToken, line, commaToken, character, closeParenToken);
+        }
+
+        public static LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken? characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
+        {
+#if DEBUG
+            if (hashToken == null) throw new ArgumentNullException(nameof(hashToken));
+            if (hashToken.Kind != SyntaxKind.HashToken) throw new ArgumentException(nameof(hashToken));
+            if (lineKeyword == null) throw new ArgumentNullException(nameof(lineKeyword));
+            if (lineKeyword.Kind != SyntaxKind.LineKeyword) throw new ArgumentException(nameof(lineKeyword));
+            if (start == null) throw new ArgumentNullException(nameof(start));
+            if (minusToken == null) throw new ArgumentNullException(nameof(minusToken));
+            if (minusToken.Kind != SyntaxKind.MinusToken) throw new ArgumentException(nameof(minusToken));
+            if (end == null) throw new ArgumentNullException(nameof(end));
+            if (characterOffset != null)
+            {
+                switch (characterOffset.Kind)
+                {
+                    case SyntaxKind.NumericLiteralToken:
+                    case SyntaxKind.None: break;
+                    default: throw new ArgumentException(nameof(characterOffset));
+                }
+            }
+            if (file == null) throw new ArgumentNullException(nameof(file));
+            if (file.Kind != SyntaxKind.StringLiteralToken) throw new ArgumentException(nameof(file));
+            if (endOfDirectiveToken == null) throw new ArgumentNullException(nameof(endOfDirectiveToken));
+            if (endOfDirectiveToken.Kind != SyntaxKind.EndOfDirectiveToken) throw new ArgumentException(nameof(endOfDirectiveToken));
+#endif
+
+            return new LineSpanDirectiveTriviaSyntax(SyntaxKind.LineSpanDirectiveTrivia, hashToken, lineKeyword, start, minusToken, end, characterOffset, file, endOfDirectiveToken, isActive);
+        }
+
         public static PragmaWarningDirectiveTriviaSyntax PragmaWarningDirectiveTrivia(SyntaxToken hashToken, SyntaxToken pragmaKeyword, SyntaxToken warningKeyword, SyntaxToken disableOrRestoreKeyword, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList<ExpressionSyntax> errorCodes, SyntaxToken endOfDirectiveToken, bool isActive)
         {
 #if DEBUG
@@ -44408,6 +44945,8 @@ internal static IEnumerable<Type> GetNodeTypes()
                 typeof(DefineDirectiveTriviaSyntax),
                 typeof(UndefDirectiveTriviaSyntax),
                 typeof(LineDirectiveTriviaSyntax),
+                typeof(LineDirectivePositionSyntax),
+                typeof(LineSpanDirectiveTriviaSyntax),
                 typeof(PragmaWarningDirectiveTriviaSyntax),
                 typeof(PragmaChecksumDirectiveTriviaSyntax),
                 typeof(ReferenceDirectiveTriviaSyntax),
diff --git a/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Main.Generated.cs b/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Main.Generated.cs
index 410d2800fb8e3..055f9fbf7187b 100644
--- a/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Main.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Main.Generated.cs
@@ -693,6 +693,12 @@ public partial class CSharpSyntaxVisitor<TResult>
         /// <summary>Called when the visitor visits a LineDirectiveTriviaSyntax node.</summary>
         public virtual TResult? VisitLineDirectiveTrivia(LineDirectiveTriviaSyntax node) => this.DefaultVisit(node);
 
+        /// <summary>Called when the visitor visits a LineDirectivePositionSyntax node.</summary>
+        public virtual TResult? VisitLineDirectivePosition(LineDirectivePositionSyntax node) => this.DefaultVisit(node);
+
+        /// <summary>Called when the visitor visits a LineSpanDirectiveTriviaSyntax node.</summary>
+        public virtual TResult? VisitLineSpanDirectiveTrivia(LineSpanDirectiveTriviaSyntax node) => this.DefaultVisit(node);
+
         /// <summary>Called when the visitor visits a PragmaWarningDirectiveTriviaSyntax node.</summary>
         public virtual TResult? VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node) => this.DefaultVisit(node);
 
@@ -1392,6 +1398,12 @@ public partial class CSharpSyntaxVisitor
         /// <summary>Called when the visitor visits a LineDirectiveTriviaSyntax node.</summary>
         public virtual void VisitLineDirectiveTrivia(LineDirectiveTriviaSyntax node) => this.DefaultVisit(node);
 
+        /// <summary>Called when the visitor visits a LineDirectivePositionSyntax node.</summary>
+        public virtual void VisitLineDirectivePosition(LineDirectivePositionSyntax node) => this.DefaultVisit(node);
+
+        /// <summary>Called when the visitor visits a LineSpanDirectiveTriviaSyntax node.</summary>
+        public virtual void VisitLineSpanDirectiveTrivia(LineSpanDirectiveTriviaSyntax node) => this.DefaultVisit(node);
+
         /// <summary>Called when the visitor visits a PragmaWarningDirectiveTriviaSyntax node.</summary>
         public virtual void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node) => this.DefaultVisit(node);
 
@@ -1579,7 +1591,7 @@ public partial class CSharpSyntaxRewriter : CSharpSyntaxVisitor<SyntaxNode?>
             => node.Update(VisitToken(node.RefKeyword), (ExpressionSyntax?)Visit(node.Expression) ?? throw new ArgumentNullException("expression"));
 
         public override SyntaxNode? VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node)
-            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (ParameterListSyntax?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList"), VisitToken(node.ArrowToken), (BlockSyntax?)Visit(node.Block), (ExpressionSyntax?)Visit(node.ExpressionBody));
+            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax?)Visit(node.ReturnType), (ParameterListSyntax?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList"), VisitToken(node.ArrowToken), (BlockSyntax?)Visit(node.Block), (ExpressionSyntax?)Visit(node.ExpressionBody));
 
         public override SyntaxNode? VisitInitializerExpression(InitializerExpressionSyntax node)
             => node.Update(VisitToken(node.OpenBraceToken), VisitList(node.Expressions), VisitToken(node.CloseBraceToken));
@@ -1936,10 +1948,10 @@ public partial class CSharpSyntaxRewriter : CSharpSyntaxVisitor<SyntaxNode?>
             => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax?)Visit(node.ReturnType) ?? throw new ArgumentNullException("returnType"), (ExplicitInterfaceSpecifierSyntax?)Visit(node.ExplicitInterfaceSpecifier), VisitToken(node.Identifier), (TypeParameterListSyntax?)Visit(node.TypeParameterList), (ParameterListSyntax?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList"), VisitList(node.ConstraintClauses), (BlockSyntax?)Visit(node.Body), (ArrowExpressionClauseSyntax?)Visit(node.ExpressionBody), VisitToken(node.SemicolonToken));
 
         public override SyntaxNode? VisitOperatorDeclaration(OperatorDeclarationSyntax node)
-            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax?)Visit(node.ReturnType) ?? throw new ArgumentNullException("returnType"), VisitToken(node.OperatorKeyword), VisitToken(node.OperatorToken), (ParameterListSyntax?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList"), (BlockSyntax?)Visit(node.Body), (ArrowExpressionClauseSyntax?)Visit(node.ExpressionBody), VisitToken(node.SemicolonToken));
+            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax?)Visit(node.ReturnType) ?? throw new ArgumentNullException("returnType"), (ExplicitInterfaceSpecifierSyntax?)Visit(node.ExplicitInterfaceSpecifier), VisitToken(node.OperatorKeyword), VisitToken(node.OperatorToken), (ParameterListSyntax?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList"), (BlockSyntax?)Visit(node.Body), (ArrowExpressionClauseSyntax?)Visit(node.ExpressionBody), VisitToken(node.SemicolonToken));
 
         public override SyntaxNode? VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node)
-            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), VisitToken(node.ImplicitOrExplicitKeyword), VisitToken(node.OperatorKeyword), (TypeSyntax?)Visit(node.Type) ?? throw new ArgumentNullException("type"), (ParameterListSyntax?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList"), (BlockSyntax?)Visit(node.Body), (ArrowExpressionClauseSyntax?)Visit(node.ExpressionBody), VisitToken(node.SemicolonToken));
+            => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), VisitToken(node.ImplicitOrExplicitKeyword), (ExplicitInterfaceSpecifierSyntax?)Visit(node.ExplicitInterfaceSpecifier), VisitToken(node.OperatorKeyword), (TypeSyntax?)Visit(node.Type) ?? throw new ArgumentNullException("type"), (ParameterListSyntax?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList"), (BlockSyntax?)Visit(node.Body), (ArrowExpressionClauseSyntax?)Visit(node.ExpressionBody), VisitToken(node.SemicolonToken));
 
         public override SyntaxNode? VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
             => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), VisitToken(node.Identifier), (ParameterListSyntax?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList"), (ConstructorInitializerSyntax?)Visit(node.Initializer), (BlockSyntax?)Visit(node.Body), (ArrowExpressionClauseSyntax?)Visit(node.ExpressionBody), VisitToken(node.SemicolonToken));
@@ -2091,6 +2103,12 @@ public partial class CSharpSyntaxRewriter : CSharpSyntaxVisitor<SyntaxNode?>
         public override SyntaxNode? VisitLineDirectiveTrivia(LineDirectiveTriviaSyntax node)
             => node.Update(VisitToken(node.HashToken), VisitToken(node.LineKeyword), VisitToken(node.Line), VisitToken(node.File), VisitToken(node.EndOfDirectiveToken), node.IsActive);
 
+        public override SyntaxNode? VisitLineDirectivePosition(LineDirectivePositionSyntax node)
+            => node.Update(VisitToken(node.OpenParenToken), VisitToken(node.Line), VisitToken(node.CommaToken), VisitToken(node.Character), VisitToken(node.CloseParenToken));
+
+        public override SyntaxNode? VisitLineSpanDirectiveTrivia(LineSpanDirectiveTriviaSyntax node)
+            => node.Update(VisitToken(node.HashToken), VisitToken(node.LineKeyword), (LineDirectivePositionSyntax?)Visit(node.Start) ?? throw new ArgumentNullException("start"), VisitToken(node.MinusToken), (LineDirectivePositionSyntax?)Visit(node.End) ?? throw new ArgumentNullException("end"), VisitToken(node.CharacterOffset), VisitToken(node.File), VisitToken(node.EndOfDirectiveToken), node.IsActive);
+
         public override SyntaxNode? VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
             => node.Update(VisitToken(node.HashToken), VisitToken(node.PragmaKeyword), VisitToken(node.WarningKeyword), VisitToken(node.DisableOrRestoreKeyword), VisitList(node.ErrorCodes), VisitToken(node.EndOfDirectiveToken), node.IsActive);
 
@@ -3092,20 +3110,20 @@ public static RefExpressionSyntax RefExpression(ExpressionSyntax expression)
             => SyntaxFactory.RefExpression(SyntaxFactory.Token(SyntaxKind.RefKeyword), expression);
 
         /// <summary>Creates a new ParenthesizedLambdaExpressionSyntax instance.</summary>
-        public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
+        public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
         {
             if (parameterList == null) throw new ArgumentNullException(nameof(parameterList));
             if (arrowToken.Kind() != SyntaxKind.EqualsGreaterThanToken) throw new ArgumentException(nameof(arrowToken));
-            return (ParenthesizedLambdaExpressionSyntax)Syntax.InternalSyntax.SyntaxFactory.ParenthesizedLambdaExpression(attributeLists.Node.ToGreenList<Syntax.InternalSyntax.AttributeListSyntax>(), modifiers.Node.ToGreenList<Syntax.InternalSyntax.SyntaxToken>(), (Syntax.InternalSyntax.ParameterListSyntax)parameterList.Green, (Syntax.InternalSyntax.SyntaxToken)arrowToken.Node!, block == null ? null : (Syntax.InternalSyntax.BlockSyntax)block.Green, expressionBody == null ? null : (Syntax.InternalSyntax.ExpressionSyntax)expressionBody.Green).CreateRed();
+            return (ParenthesizedLambdaExpressionSyntax)Syntax.InternalSyntax.SyntaxFactory.ParenthesizedLambdaExpression(attributeLists.Node.ToGreenList<Syntax.InternalSyntax.AttributeListSyntax>(), modifiers.Node.ToGreenList<Syntax.InternalSyntax.SyntaxToken>(), returnType == null ? null : (Syntax.InternalSyntax.TypeSyntax)returnType.Green, (Syntax.InternalSyntax.ParameterListSyntax)parameterList.Green, (Syntax.InternalSyntax.SyntaxToken)arrowToken.Node!, block == null ? null : (Syntax.InternalSyntax.BlockSyntax)block.Green, expressionBody == null ? null : (Syntax.InternalSyntax.ExpressionSyntax)expressionBody.Green).CreateRed();
         }
 
         /// <summary>Creates a new ParenthesizedLambdaExpressionSyntax instance.</summary>
-        public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, ParameterListSyntax parameterList, BlockSyntax? block, ExpressionSyntax? expressionBody)
-            => SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, parameterList, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), block, expressionBody);
+        public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, BlockSyntax? block, ExpressionSyntax? expressionBody)
+            => SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, returnType, parameterList, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), block, expressionBody);
 
         /// <summary>Creates a new ParenthesizedLambdaExpressionSyntax instance.</summary>
         public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression()
-            => SyntaxFactory.ParenthesizedLambdaExpression(default, default(SyntaxTokenList), SyntaxFactory.ParameterList(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default, default);
+            => SyntaxFactory.ParenthesizedLambdaExpression(default, default(SyntaxTokenList), default, SyntaxFactory.ParameterList(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default, default);
 
         /// <summary>Creates a new InitializerExpressionSyntax instance.</summary>
         public static InitializerExpressionSyntax InitializerExpression(SyntaxKind kind, SyntaxToken openBraceToken, SeparatedSyntaxList<ExpressionSyntax> expressions, SyntaxToken closeBraceToken)
@@ -5130,7 +5148,7 @@ public static MethodDeclarationSyntax MethodDeclaration(TypeSyntax returnType, s
             => SyntaxFactory.MethodDeclaration(default, default(SyntaxTokenList), returnType, default, SyntaxFactory.Identifier(identifier), default, SyntaxFactory.ParameterList(), default, default, default, default);
 
         /// <summary>Creates a new OperatorDeclarationSyntax instance.</summary>
-        public static OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
+        public static OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
         {
             if (returnType == null) throw new ArgumentNullException(nameof(returnType));
             if (operatorKeyword.Kind() != SyntaxKind.OperatorKeyword) throw new ArgumentException(nameof(operatorKeyword));
@@ -5168,19 +5186,19 @@ public static OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<Attribute
                 case SyntaxKind.None: break;
                 default: throw new ArgumentException(nameof(semicolonToken));
             }
-            return (OperatorDeclarationSyntax)Syntax.InternalSyntax.SyntaxFactory.OperatorDeclaration(attributeLists.Node.ToGreenList<Syntax.InternalSyntax.AttributeListSyntax>(), modifiers.Node.ToGreenList<Syntax.InternalSyntax.SyntaxToken>(), (Syntax.InternalSyntax.TypeSyntax)returnType.Green, (Syntax.InternalSyntax.SyntaxToken)operatorKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)operatorToken.Node!, (Syntax.InternalSyntax.ParameterListSyntax)parameterList.Green, body == null ? null : (Syntax.InternalSyntax.BlockSyntax)body.Green, expressionBody == null ? null : (Syntax.InternalSyntax.ArrowExpressionClauseSyntax)expressionBody.Green, (Syntax.InternalSyntax.SyntaxToken?)semicolonToken.Node).CreateRed();
+            return (OperatorDeclarationSyntax)Syntax.InternalSyntax.SyntaxFactory.OperatorDeclaration(attributeLists.Node.ToGreenList<Syntax.InternalSyntax.AttributeListSyntax>(), modifiers.Node.ToGreenList<Syntax.InternalSyntax.SyntaxToken>(), (Syntax.InternalSyntax.TypeSyntax)returnType.Green, explicitInterfaceSpecifier == null ? null : (Syntax.InternalSyntax.ExplicitInterfaceSpecifierSyntax)explicitInterfaceSpecifier.Green, (Syntax.InternalSyntax.SyntaxToken)operatorKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)operatorToken.Node!, (Syntax.InternalSyntax.ParameterListSyntax)parameterList.Green, body == null ? null : (Syntax.InternalSyntax.BlockSyntax)body.Green, expressionBody == null ? null : (Syntax.InternalSyntax.ArrowExpressionClauseSyntax)expressionBody.Green, (Syntax.InternalSyntax.SyntaxToken?)semicolonToken.Node).CreateRed();
         }
 
         /// <summary>Creates a new OperatorDeclarationSyntax instance.</summary>
-        public static OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody)
-            => SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), operatorToken, parameterList, body, expressionBody, default);
+        public static OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody)
+            => SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), operatorToken, parameterList, body, expressionBody, default);
 
         /// <summary>Creates a new OperatorDeclarationSyntax instance.</summary>
         public static OperatorDeclarationSyntax OperatorDeclaration(TypeSyntax returnType, SyntaxToken operatorToken)
-            => SyntaxFactory.OperatorDeclaration(default, default(SyntaxTokenList), returnType, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), operatorToken, SyntaxFactory.ParameterList(), default, default, default);
+            => SyntaxFactory.OperatorDeclaration(default, default(SyntaxTokenList), returnType, default, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), operatorToken, SyntaxFactory.ParameterList(), default, default, default);
 
         /// <summary>Creates a new ConversionOperatorDeclarationSyntax instance.</summary>
-        public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
+        public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
         {
             switch (implicitOrExplicitKeyword.Kind())
             {
@@ -5197,16 +5215,16 @@ public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(
                 case SyntaxKind.None: break;
                 default: throw new ArgumentException(nameof(semicolonToken));
             }
-            return (ConversionOperatorDeclarationSyntax)Syntax.InternalSyntax.SyntaxFactory.ConversionOperatorDeclaration(attributeLists.Node.ToGreenList<Syntax.InternalSyntax.AttributeListSyntax>(), modifiers.Node.ToGreenList<Syntax.InternalSyntax.SyntaxToken>(), (Syntax.InternalSyntax.SyntaxToken)implicitOrExplicitKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)operatorKeyword.Node!, (Syntax.InternalSyntax.TypeSyntax)type.Green, (Syntax.InternalSyntax.ParameterListSyntax)parameterList.Green, body == null ? null : (Syntax.InternalSyntax.BlockSyntax)body.Green, expressionBody == null ? null : (Syntax.InternalSyntax.ArrowExpressionClauseSyntax)expressionBody.Green, (Syntax.InternalSyntax.SyntaxToken?)semicolonToken.Node).CreateRed();
+            return (ConversionOperatorDeclarationSyntax)Syntax.InternalSyntax.SyntaxFactory.ConversionOperatorDeclaration(attributeLists.Node.ToGreenList<Syntax.InternalSyntax.AttributeListSyntax>(), modifiers.Node.ToGreenList<Syntax.InternalSyntax.SyntaxToken>(), (Syntax.InternalSyntax.SyntaxToken)implicitOrExplicitKeyword.Node!, explicitInterfaceSpecifier == null ? null : (Syntax.InternalSyntax.ExplicitInterfaceSpecifierSyntax)explicitInterfaceSpecifier.Green, (Syntax.InternalSyntax.SyntaxToken)operatorKeyword.Node!, (Syntax.InternalSyntax.TypeSyntax)type.Green, (Syntax.InternalSyntax.ParameterListSyntax)parameterList.Green, body == null ? null : (Syntax.InternalSyntax.BlockSyntax)body.Green, expressionBody == null ? null : (Syntax.InternalSyntax.ArrowExpressionClauseSyntax)expressionBody.Green, (Syntax.InternalSyntax.SyntaxToken?)semicolonToken.Node).CreateRed();
         }
 
         /// <summary>Creates a new ConversionOperatorDeclarationSyntax instance.</summary>
-        public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody)
-            => SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), type, parameterList, body, expressionBody, default);
+        public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody)
+            => SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, explicitInterfaceSpecifier, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), type, parameterList, body, expressionBody, default);
 
         /// <summary>Creates a new ConversionOperatorDeclarationSyntax instance.</summary>
         public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxToken implicitOrExplicitKeyword, TypeSyntax type)
-            => SyntaxFactory.ConversionOperatorDeclaration(default, default(SyntaxTokenList), implicitOrExplicitKeyword, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), type, SyntaxFactory.ParameterList(), default, default, default);
+            => SyntaxFactory.ConversionOperatorDeclaration(default, default(SyntaxTokenList), implicitOrExplicitKeyword, default, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), type, SyntaxFactory.ParameterList(), default, default, default);
 
         /// <summary>Creates a new ConstructorDeclarationSyntax instance.</summary>
         public static ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, ParameterListSyntax parameterList, ConstructorInitializerSyntax? initializer, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
@@ -6090,6 +6108,48 @@ public static LineDirectiveTriviaSyntax LineDirectiveTrivia(SyntaxToken line, Sy
         public static LineDirectiveTriviaSyntax LineDirectiveTrivia(SyntaxToken line, bool isActive)
             => SyntaxFactory.LineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), line, default, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive);
 
+        /// <summary>Creates a new LineDirectivePositionSyntax instance.</summary>
+        public static LineDirectivePositionSyntax LineDirectivePosition(SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken)
+        {
+            if (openParenToken.Kind() != SyntaxKind.OpenParenToken) throw new ArgumentException(nameof(openParenToken));
+            if (line.Kind() != SyntaxKind.NumericLiteralToken) throw new ArgumentException(nameof(line));
+            if (commaToken.Kind() != SyntaxKind.CommaToken) throw new ArgumentException(nameof(commaToken));
+            if (character.Kind() != SyntaxKind.NumericLiteralToken) throw new ArgumentException(nameof(character));
+            if (closeParenToken.Kind() != SyntaxKind.CloseParenToken) throw new ArgumentException(nameof(closeParenToken));
+            return (LineDirectivePositionSyntax)Syntax.InternalSyntax.SyntaxFactory.LineDirectivePosition((Syntax.InternalSyntax.SyntaxToken)openParenToken.Node!, (Syntax.InternalSyntax.SyntaxToken)line.Node!, (Syntax.InternalSyntax.SyntaxToken)commaToken.Node!, (Syntax.InternalSyntax.SyntaxToken)character.Node!, (Syntax.InternalSyntax.SyntaxToken)closeParenToken.Node!).CreateRed();
+        }
+
+        /// <summary>Creates a new LineDirectivePositionSyntax instance.</summary>
+        public static LineDirectivePositionSyntax LineDirectivePosition(SyntaxToken line, SyntaxToken character)
+            => SyntaxFactory.LineDirectivePosition(SyntaxFactory.Token(SyntaxKind.OpenParenToken), line, SyntaxFactory.Token(SyntaxKind.CommaToken), character, SyntaxFactory.Token(SyntaxKind.CloseParenToken));
+
+        /// <summary>Creates a new LineSpanDirectiveTriviaSyntax instance.</summary>
+        public static LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
+        {
+            if (hashToken.Kind() != SyntaxKind.HashToken) throw new ArgumentException(nameof(hashToken));
+            if (lineKeyword.Kind() != SyntaxKind.LineKeyword) throw new ArgumentException(nameof(lineKeyword));
+            if (start == null) throw new ArgumentNullException(nameof(start));
+            if (minusToken.Kind() != SyntaxKind.MinusToken) throw new ArgumentException(nameof(minusToken));
+            if (end == null) throw new ArgumentNullException(nameof(end));
+            switch (characterOffset.Kind())
+            {
+                case SyntaxKind.NumericLiteralToken:
+                case SyntaxKind.None: break;
+                default: throw new ArgumentException(nameof(characterOffset));
+            }
+            if (file.Kind() != SyntaxKind.StringLiteralToken) throw new ArgumentException(nameof(file));
+            if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken) throw new ArgumentException(nameof(endOfDirectiveToken));
+            return (LineSpanDirectiveTriviaSyntax)Syntax.InternalSyntax.SyntaxFactory.LineSpanDirectiveTrivia((Syntax.InternalSyntax.SyntaxToken)hashToken.Node!, (Syntax.InternalSyntax.SyntaxToken)lineKeyword.Node!, (Syntax.InternalSyntax.LineDirectivePositionSyntax)start.Green, (Syntax.InternalSyntax.SyntaxToken)minusToken.Node!, (Syntax.InternalSyntax.LineDirectivePositionSyntax)end.Green, (Syntax.InternalSyntax.SyntaxToken?)characterOffset.Node, (Syntax.InternalSyntax.SyntaxToken)file.Node!, (Syntax.InternalSyntax.SyntaxToken)endOfDirectiveToken.Node!, isActive).CreateRed();
+        }
+
+        /// <summary>Creates a new LineSpanDirectiveTriviaSyntax instance.</summary>
+        public static LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(LineDirectivePositionSyntax start, LineDirectivePositionSyntax end, SyntaxToken characterOffset, SyntaxToken file, bool isActive)
+            => SyntaxFactory.LineSpanDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), start, SyntaxFactory.Token(SyntaxKind.MinusToken), end, characterOffset, file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive);
+
+        /// <summary>Creates a new LineSpanDirectiveTriviaSyntax instance.</summary>
+        public static LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(LineDirectivePositionSyntax start, LineDirectivePositionSyntax end, SyntaxToken file, bool isActive)
+            => SyntaxFactory.LineSpanDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), start, SyntaxFactory.Token(SyntaxKind.MinusToken), end, default, file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive);
+
         /// <summary>Creates a new PragmaWarningDirectiveTriviaSyntax instance.</summary>
         public static PragmaWarningDirectiveTriviaSyntax PragmaWarningDirectiveTrivia(SyntaxToken hashToken, SyntaxToken pragmaKeyword, SyntaxToken warningKeyword, SyntaxToken disableOrRestoreKeyword, SeparatedSyntaxList<ExpressionSyntax> errorCodes, SyntaxToken endOfDirectiveToken, bool isActive)
         {
diff --git a/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Syntax.Generated.cs b/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Syntax.Generated.cs
index 5b55110645191..042ac762357c0 100644
--- a/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Syntax.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Syntax.Generated.cs
@@ -3271,6 +3271,7 @@ public RefExpressionSyntax Update(SyntaxToken refKeyword, ExpressionSyntax expre
     public sealed partial class ParenthesizedLambdaExpressionSyntax : LambdaExpressionSyntax
     {
         private SyntaxNode? attributeLists;
+        private TypeSyntax? returnType;
         private ParameterListSyntax? parameterList;
         private BlockSyntax? block;
         private ExpressionSyntax? expressionBody;
@@ -3291,31 +3292,34 @@ public override SyntaxTokenList Modifiers
             }
         }
 
+        public TypeSyntax? ReturnType => GetRed(ref this.returnType, 2);
+
         /// <summary>ParameterListSyntax node representing the list of parameters for the lambda expression.</summary>
-        public ParameterListSyntax ParameterList => GetRed(ref this.parameterList, 2)!;
+        public ParameterListSyntax ParameterList => GetRed(ref this.parameterList, 3)!;
 
         /// <summary>SyntaxToken representing equals greater than.</summary>
-        public override SyntaxToken ArrowToken => new SyntaxToken(this, ((Syntax.InternalSyntax.ParenthesizedLambdaExpressionSyntax)this.Green).arrowToken, GetChildPosition(3), GetChildIndex(3));
+        public override SyntaxToken ArrowToken => new SyntaxToken(this, ((Syntax.InternalSyntax.ParenthesizedLambdaExpressionSyntax)this.Green).arrowToken, GetChildPosition(4), GetChildIndex(4));
 
         /// <summary>
         /// BlockSyntax node representing the body of the lambda.
         /// Only one of Block or ExpressionBody will be non-null.
         /// </summary>
-        public override BlockSyntax? Block => GetRed(ref this.block, 4);
+        public override BlockSyntax? Block => GetRed(ref this.block, 5);
 
         /// <summary>
         /// ExpressionSyntax node representing the body of the lambda.
         /// Only one of Block or ExpressionBody will be non-null.
         /// </summary>
-        public override ExpressionSyntax? ExpressionBody => GetRed(ref this.expressionBody, 5);
+        public override ExpressionSyntax? ExpressionBody => GetRed(ref this.expressionBody, 6);
 
         internal override SyntaxNode? GetNodeSlot(int index)
             => index switch
             {
                 0 => GetRedAtZero(ref this.attributeLists)!,
-                2 => GetRed(ref this.parameterList, 2)!,
-                4 => GetRed(ref this.block, 4),
-                5 => GetRed(ref this.expressionBody, 5),
+                2 => GetRed(ref this.returnType, 2),
+                3 => GetRed(ref this.parameterList, 3)!,
+                5 => GetRed(ref this.block, 5),
+                6 => GetRed(ref this.expressionBody, 6),
                 _ => null,
             };
 
@@ -3323,20 +3327,21 @@ public override SyntaxTokenList Modifiers
             => index switch
             {
                 0 => this.attributeLists,
-                2 => this.parameterList,
-                4 => this.block,
-                5 => this.expressionBody,
+                2 => this.returnType,
+                3 => this.parameterList,
+                5 => this.block,
+                6 => this.expressionBody,
                 _ => null,
             };
 
         public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitParenthesizedLambdaExpression(this);
         public override TResult? Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) where TResult : default => visitor.VisitParenthesizedLambdaExpression(this);
 
-        public ParenthesizedLambdaExpressionSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
+        public ParenthesizedLambdaExpressionSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
         {
-            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || parameterList != this.ParameterList || arrowToken != this.ArrowToken || block != this.Block || expressionBody != this.ExpressionBody)
+            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || returnType != this.ReturnType || parameterList != this.ParameterList || arrowToken != this.ArrowToken || block != this.Block || expressionBody != this.ExpressionBody)
             {
-                var newNode = SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, parameterList, arrowToken, block, expressionBody);
+                var newNode = SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, returnType, parameterList, arrowToken, block, expressionBody);
                 var annotations = GetAnnotations();
                 return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode;
             }
@@ -3345,16 +3350,17 @@ public ParenthesizedLambdaExpressionSyntax Update(SyntaxList<AttributeListSyntax
         }
 
         internal override LambdaExpressionSyntax WithAttributeListsCore(SyntaxList<AttributeListSyntax> attributeLists) => WithAttributeLists(attributeLists);
-        public new ParenthesizedLambdaExpressionSyntax WithAttributeLists(SyntaxList<AttributeListSyntax> attributeLists) => Update(attributeLists, this.Modifiers, this.ParameterList, this.ArrowToken, this.Block, this.ExpressionBody);
+        public new ParenthesizedLambdaExpressionSyntax WithAttributeLists(SyntaxList<AttributeListSyntax> attributeLists) => Update(attributeLists, this.Modifiers, this.ReturnType, this.ParameterList, this.ArrowToken, this.Block, this.ExpressionBody);
         internal override AnonymousFunctionExpressionSyntax WithModifiersCore(SyntaxTokenList modifiers) => WithModifiers(modifiers);
-        public new ParenthesizedLambdaExpressionSyntax WithModifiers(SyntaxTokenList modifiers) => Update(this.AttributeLists, modifiers, this.ParameterList, this.ArrowToken, this.Block, this.ExpressionBody);
-        public ParenthesizedLambdaExpressionSyntax WithParameterList(ParameterListSyntax parameterList) => Update(this.AttributeLists, this.Modifiers, parameterList, this.ArrowToken, this.Block, this.ExpressionBody);
+        public new ParenthesizedLambdaExpressionSyntax WithModifiers(SyntaxTokenList modifiers) => Update(this.AttributeLists, modifiers, this.ReturnType, this.ParameterList, this.ArrowToken, this.Block, this.ExpressionBody);
+        public ParenthesizedLambdaExpressionSyntax WithReturnType(TypeSyntax? returnType) => Update(this.AttributeLists, this.Modifiers, returnType, this.ParameterList, this.ArrowToken, this.Block, this.ExpressionBody);
+        public ParenthesizedLambdaExpressionSyntax WithParameterList(ParameterListSyntax parameterList) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, parameterList, this.ArrowToken, this.Block, this.ExpressionBody);
         internal override LambdaExpressionSyntax WithArrowTokenCore(SyntaxToken arrowToken) => WithArrowToken(arrowToken);
-        public new ParenthesizedLambdaExpressionSyntax WithArrowToken(SyntaxToken arrowToken) => Update(this.AttributeLists, this.Modifiers, this.ParameterList, arrowToken, this.Block, this.ExpressionBody);
+        public new ParenthesizedLambdaExpressionSyntax WithArrowToken(SyntaxToken arrowToken) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.ParameterList, arrowToken, this.Block, this.ExpressionBody);
         internal override AnonymousFunctionExpressionSyntax WithBlockCore(BlockSyntax? block) => WithBlock(block);
-        public new ParenthesizedLambdaExpressionSyntax WithBlock(BlockSyntax? block) => Update(this.AttributeLists, this.Modifiers, this.ParameterList, this.ArrowToken, block, this.ExpressionBody);
+        public new ParenthesizedLambdaExpressionSyntax WithBlock(BlockSyntax? block) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.ParameterList, this.ArrowToken, block, this.ExpressionBody);
         internal override AnonymousFunctionExpressionSyntax WithExpressionBodyCore(ExpressionSyntax? expressionBody) => WithExpressionBody(expressionBody);
-        public new ParenthesizedLambdaExpressionSyntax WithExpressionBody(ExpressionSyntax? expressionBody) => Update(this.AttributeLists, this.Modifiers, this.ParameterList, this.ArrowToken, this.Block, expressionBody);
+        public new ParenthesizedLambdaExpressionSyntax WithExpressionBody(ExpressionSyntax? expressionBody) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.ParameterList, this.ArrowToken, this.Block, expressionBody);
 
         internal override LambdaExpressionSyntax AddAttributeListsCore(params AttributeListSyntax[] items) => AddAttributeLists(items);
         public new ParenthesizedLambdaExpressionSyntax AddAttributeLists(params AttributeListSyntax[] items) => WithAttributeLists(this.AttributeLists.AddRange(items));
@@ -11550,6 +11556,7 @@ public sealed partial class OperatorDeclarationSyntax : BaseMethodDeclarationSyn
     {
         private SyntaxNode? attributeLists;
         private TypeSyntax? returnType;
+        private ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier;
         private ParameterListSyntax? parameterList;
         private BlockSyntax? body;
         private ArrowExpressionClauseSyntax? expressionBody;
@@ -11573,17 +11580,19 @@ public override SyntaxTokenList Modifiers
         /// <summary>Gets the return type.</summary>
         public TypeSyntax ReturnType => GetRed(ref this.returnType, 2)!;
 
+        public ExplicitInterfaceSpecifierSyntax? ExplicitInterfaceSpecifier => GetRed(ref this.explicitInterfaceSpecifier, 3);
+
         /// <summary>Gets the "operator" keyword.</summary>
-        public SyntaxToken OperatorKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.OperatorDeclarationSyntax)this.Green).operatorKeyword, GetChildPosition(3), GetChildIndex(3));
+        public SyntaxToken OperatorKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.OperatorDeclarationSyntax)this.Green).operatorKeyword, GetChildPosition(4), GetChildIndex(4));
 
         /// <summary>Gets the operator token.</summary>
-        public SyntaxToken OperatorToken => new SyntaxToken(this, ((Syntax.InternalSyntax.OperatorDeclarationSyntax)this.Green).operatorToken, GetChildPosition(4), GetChildIndex(4));
+        public SyntaxToken OperatorToken => new SyntaxToken(this, ((Syntax.InternalSyntax.OperatorDeclarationSyntax)this.Green).operatorToken, GetChildPosition(5), GetChildIndex(5));
 
-        public override ParameterListSyntax ParameterList => GetRed(ref this.parameterList, 5)!;
+        public override ParameterListSyntax ParameterList => GetRed(ref this.parameterList, 6)!;
 
-        public override BlockSyntax? Body => GetRed(ref this.body, 6);
+        public override BlockSyntax? Body => GetRed(ref this.body, 7);
 
-        public override ArrowExpressionClauseSyntax? ExpressionBody => GetRed(ref this.expressionBody, 7);
+        public override ArrowExpressionClauseSyntax? ExpressionBody => GetRed(ref this.expressionBody, 8);
 
         /// <summary>Gets the optional semicolon token.</summary>
         public override SyntaxToken SemicolonToken
@@ -11591,7 +11600,7 @@ public override SyntaxToken SemicolonToken
             get
             {
                 var slot = ((Syntax.InternalSyntax.OperatorDeclarationSyntax)this.Green).semicolonToken;
-                return slot != null ? new SyntaxToken(this, slot, GetChildPosition(8), GetChildIndex(8)) : default;
+                return slot != null ? new SyntaxToken(this, slot, GetChildPosition(9), GetChildIndex(9)) : default;
             }
         }
 
@@ -11600,9 +11609,10 @@ public override SyntaxToken SemicolonToken
             {
                 0 => GetRedAtZero(ref this.attributeLists)!,
                 2 => GetRed(ref this.returnType, 2)!,
-                5 => GetRed(ref this.parameterList, 5)!,
-                6 => GetRed(ref this.body, 6),
-                7 => GetRed(ref this.expressionBody, 7),
+                3 => GetRed(ref this.explicitInterfaceSpecifier, 3),
+                6 => GetRed(ref this.parameterList, 6)!,
+                7 => GetRed(ref this.body, 7),
+                8 => GetRed(ref this.expressionBody, 8),
                 _ => null,
             };
 
@@ -11611,20 +11621,21 @@ public override SyntaxToken SemicolonToken
             {
                 0 => this.attributeLists,
                 2 => this.returnType,
-                5 => this.parameterList,
-                6 => this.body,
-                7 => this.expressionBody,
+                3 => this.explicitInterfaceSpecifier,
+                6 => this.parameterList,
+                7 => this.body,
+                8 => this.expressionBody,
                 _ => null,
             };
 
         public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitOperatorDeclaration(this);
         public override TResult? Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) where TResult : default => visitor.VisitOperatorDeclaration(this);
 
-        public OperatorDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
+        public OperatorDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
         {
-            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || returnType != this.ReturnType || operatorKeyword != this.OperatorKeyword || operatorToken != this.OperatorToken || parameterList != this.ParameterList || body != this.Body || expressionBody != this.ExpressionBody || semicolonToken != this.SemicolonToken)
+            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || returnType != this.ReturnType || explicitInterfaceSpecifier != this.ExplicitInterfaceSpecifier || operatorKeyword != this.OperatorKeyword || operatorToken != this.OperatorToken || parameterList != this.ParameterList || body != this.Body || expressionBody != this.ExpressionBody || semicolonToken != this.SemicolonToken)
             {
-                var newNode = SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, operatorKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken);
+                var newNode = SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, operatorKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken);
                 var annotations = GetAnnotations();
                 return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode;
             }
@@ -11633,20 +11644,21 @@ public OperatorDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attribut
         }
 
         internal override MemberDeclarationSyntax WithAttributeListsCore(SyntaxList<AttributeListSyntax> attributeLists) => WithAttributeLists(attributeLists);
-        public new OperatorDeclarationSyntax WithAttributeLists(SyntaxList<AttributeListSyntax> attributeLists) => Update(attributeLists, this.Modifiers, this.ReturnType, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public new OperatorDeclarationSyntax WithAttributeLists(SyntaxList<AttributeListSyntax> attributeLists) => Update(attributeLists, this.Modifiers, this.ReturnType, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
         internal override MemberDeclarationSyntax WithModifiersCore(SyntaxTokenList modifiers) => WithModifiers(modifiers);
-        public new OperatorDeclarationSyntax WithModifiers(SyntaxTokenList modifiers) => Update(this.AttributeLists, modifiers, this.ReturnType, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
-        public OperatorDeclarationSyntax WithReturnType(TypeSyntax returnType) => Update(this.AttributeLists, this.Modifiers, returnType, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
-        public OperatorDeclarationSyntax WithOperatorKeyword(SyntaxToken operatorKeyword) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, operatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
-        public OperatorDeclarationSyntax WithOperatorToken(SyntaxToken operatorToken) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.OperatorKeyword, operatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public new OperatorDeclarationSyntax WithModifiers(SyntaxTokenList modifiers) => Update(this.AttributeLists, modifiers, this.ReturnType, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public OperatorDeclarationSyntax WithReturnType(TypeSyntax returnType) => Update(this.AttributeLists, this.Modifiers, returnType, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public OperatorDeclarationSyntax WithExplicitInterfaceSpecifier(ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, explicitInterfaceSpecifier, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public OperatorDeclarationSyntax WithOperatorKeyword(SyntaxToken operatorKeyword) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.ExplicitInterfaceSpecifier, operatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public OperatorDeclarationSyntax WithOperatorToken(SyntaxToken operatorToken) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, operatorToken, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
         internal override BaseMethodDeclarationSyntax WithParameterListCore(ParameterListSyntax parameterList) => WithParameterList(parameterList);
-        public new OperatorDeclarationSyntax WithParameterList(ParameterListSyntax parameterList) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.OperatorKeyword, this.OperatorToken, parameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public new OperatorDeclarationSyntax WithParameterList(ParameterListSyntax parameterList) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.OperatorToken, parameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
         internal override BaseMethodDeclarationSyntax WithBodyCore(BlockSyntax? body) => WithBody(body);
-        public new OperatorDeclarationSyntax WithBody(BlockSyntax? body) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.OperatorKeyword, this.OperatorToken, this.ParameterList, body, this.ExpressionBody, this.SemicolonToken);
+        public new OperatorDeclarationSyntax WithBody(BlockSyntax? body) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.OperatorToken, this.ParameterList, body, this.ExpressionBody, this.SemicolonToken);
         internal override BaseMethodDeclarationSyntax WithExpressionBodyCore(ArrowExpressionClauseSyntax? expressionBody) => WithExpressionBody(expressionBody);
-        public new OperatorDeclarationSyntax WithExpressionBody(ArrowExpressionClauseSyntax? expressionBody) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, expressionBody, this.SemicolonToken);
+        public new OperatorDeclarationSyntax WithExpressionBody(ArrowExpressionClauseSyntax? expressionBody) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, expressionBody, this.SemicolonToken);
         internal override BaseMethodDeclarationSyntax WithSemicolonTokenCore(SyntaxToken semicolonToken) => WithSemicolonToken(semicolonToken);
-        public new OperatorDeclarationSyntax WithSemicolonToken(SyntaxToken semicolonToken) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, semicolonToken);
+        public new OperatorDeclarationSyntax WithSemicolonToken(SyntaxToken semicolonToken) => Update(this.AttributeLists, this.Modifiers, this.ReturnType, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.OperatorToken, this.ParameterList, this.Body, this.ExpressionBody, semicolonToken);
 
         internal override MemberDeclarationSyntax AddAttributeListsCore(params AttributeListSyntax[] items) => AddAttributeLists(items);
         public new OperatorDeclarationSyntax AddAttributeLists(params AttributeListSyntax[] items) => WithAttributeLists(this.AttributeLists.AddRange(items));
@@ -11678,6 +11690,7 @@ public OperatorDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attribut
     public sealed partial class ConversionOperatorDeclarationSyntax : BaseMethodDeclarationSyntax
     {
         private SyntaxNode? attributeLists;
+        private ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier;
         private TypeSyntax? type;
         private ParameterListSyntax? parameterList;
         private BlockSyntax? body;
@@ -11702,17 +11715,19 @@ public override SyntaxTokenList Modifiers
         /// <summary>Gets the "implicit" or "explicit" token.</summary>
         public SyntaxToken ImplicitOrExplicitKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax)this.Green).implicitOrExplicitKeyword, GetChildPosition(2), GetChildIndex(2));
 
+        public ExplicitInterfaceSpecifierSyntax? ExplicitInterfaceSpecifier => GetRed(ref this.explicitInterfaceSpecifier, 3);
+
         /// <summary>Gets the "operator" token.</summary>
-        public SyntaxToken OperatorKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax)this.Green).operatorKeyword, GetChildPosition(3), GetChildIndex(3));
+        public SyntaxToken OperatorKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax)this.Green).operatorKeyword, GetChildPosition(4), GetChildIndex(4));
 
         /// <summary>Gets the type.</summary>
-        public TypeSyntax Type => GetRed(ref this.type, 4)!;
+        public TypeSyntax Type => GetRed(ref this.type, 5)!;
 
-        public override ParameterListSyntax ParameterList => GetRed(ref this.parameterList, 5)!;
+        public override ParameterListSyntax ParameterList => GetRed(ref this.parameterList, 6)!;
 
-        public override BlockSyntax? Body => GetRed(ref this.body, 6);
+        public override BlockSyntax? Body => GetRed(ref this.body, 7);
 
-        public override ArrowExpressionClauseSyntax? ExpressionBody => GetRed(ref this.expressionBody, 7);
+        public override ArrowExpressionClauseSyntax? ExpressionBody => GetRed(ref this.expressionBody, 8);
 
         /// <summary>Gets the optional semicolon token.</summary>
         public override SyntaxToken SemicolonToken
@@ -11720,7 +11735,7 @@ public override SyntaxToken SemicolonToken
             get
             {
                 var slot = ((Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax)this.Green).semicolonToken;
-                return slot != null ? new SyntaxToken(this, slot, GetChildPosition(8), GetChildIndex(8)) : default;
+                return slot != null ? new SyntaxToken(this, slot, GetChildPosition(9), GetChildIndex(9)) : default;
             }
         }
 
@@ -11728,10 +11743,11 @@ public override SyntaxToken SemicolonToken
             => index switch
             {
                 0 => GetRedAtZero(ref this.attributeLists)!,
-                4 => GetRed(ref this.type, 4)!,
-                5 => GetRed(ref this.parameterList, 5)!,
-                6 => GetRed(ref this.body, 6),
-                7 => GetRed(ref this.expressionBody, 7),
+                3 => GetRed(ref this.explicitInterfaceSpecifier, 3),
+                5 => GetRed(ref this.type, 5)!,
+                6 => GetRed(ref this.parameterList, 6)!,
+                7 => GetRed(ref this.body, 7),
+                8 => GetRed(ref this.expressionBody, 8),
                 _ => null,
             };
 
@@ -11739,21 +11755,22 @@ public override SyntaxToken SemicolonToken
             => index switch
             {
                 0 => this.attributeLists,
-                4 => this.type,
-                5 => this.parameterList,
-                6 => this.body,
-                7 => this.expressionBody,
+                3 => this.explicitInterfaceSpecifier,
+                5 => this.type,
+                6 => this.parameterList,
+                7 => this.body,
+                8 => this.expressionBody,
                 _ => null,
             };
 
         public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitConversionOperatorDeclaration(this);
         public override TResult? Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) where TResult : default => visitor.VisitConversionOperatorDeclaration(this);
 
-        public ConversionOperatorDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
+        public ConversionOperatorDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
         {
-            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || implicitOrExplicitKeyword != this.ImplicitOrExplicitKeyword || operatorKeyword != this.OperatorKeyword || type != this.Type || parameterList != this.ParameterList || body != this.Body || expressionBody != this.ExpressionBody || semicolonToken != this.SemicolonToken)
+            if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || implicitOrExplicitKeyword != this.ImplicitOrExplicitKeyword || explicitInterfaceSpecifier != this.ExplicitInterfaceSpecifier || operatorKeyword != this.OperatorKeyword || type != this.Type || parameterList != this.ParameterList || body != this.Body || expressionBody != this.ExpressionBody || semicolonToken != this.SemicolonToken)
             {
-                var newNode = SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, operatorKeyword, type, parameterList, body, expressionBody, semicolonToken);
+                var newNode = SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, explicitInterfaceSpecifier, operatorKeyword, type, parameterList, body, expressionBody, semicolonToken);
                 var annotations = GetAnnotations();
                 return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode;
             }
@@ -11762,20 +11779,21 @@ public ConversionOperatorDeclarationSyntax Update(SyntaxList<AttributeListSyntax
         }
 
         internal override MemberDeclarationSyntax WithAttributeListsCore(SyntaxList<AttributeListSyntax> attributeLists) => WithAttributeLists(attributeLists);
-        public new ConversionOperatorDeclarationSyntax WithAttributeLists(SyntaxList<AttributeListSyntax> attributeLists) => Update(attributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public new ConversionOperatorDeclarationSyntax WithAttributeLists(SyntaxList<AttributeListSyntax> attributeLists) => Update(attributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
         internal override MemberDeclarationSyntax WithModifiersCore(SyntaxTokenList modifiers) => WithModifiers(modifiers);
-        public new ConversionOperatorDeclarationSyntax WithModifiers(SyntaxTokenList modifiers) => Update(this.AttributeLists, modifiers, this.ImplicitOrExplicitKeyword, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
-        public ConversionOperatorDeclarationSyntax WithImplicitOrExplicitKeyword(SyntaxToken implicitOrExplicitKeyword) => Update(this.AttributeLists, this.Modifiers, implicitOrExplicitKeyword, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
-        public ConversionOperatorDeclarationSyntax WithOperatorKeyword(SyntaxToken operatorKeyword) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, operatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
-        public ConversionOperatorDeclarationSyntax WithType(TypeSyntax type) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.OperatorKeyword, type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public new ConversionOperatorDeclarationSyntax WithModifiers(SyntaxTokenList modifiers) => Update(this.AttributeLists, modifiers, this.ImplicitOrExplicitKeyword, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public ConversionOperatorDeclarationSyntax WithImplicitOrExplicitKeyword(SyntaxToken implicitOrExplicitKeyword) => Update(this.AttributeLists, this.Modifiers, implicitOrExplicitKeyword, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public ConversionOperatorDeclarationSyntax WithExplicitInterfaceSpecifier(ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, explicitInterfaceSpecifier, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public ConversionOperatorDeclarationSyntax WithOperatorKeyword(SyntaxToken operatorKeyword) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.ExplicitInterfaceSpecifier, operatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public ConversionOperatorDeclarationSyntax WithType(TypeSyntax type) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, type, this.ParameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
         internal override BaseMethodDeclarationSyntax WithParameterListCore(ParameterListSyntax parameterList) => WithParameterList(parameterList);
-        public new ConversionOperatorDeclarationSyntax WithParameterList(ParameterListSyntax parameterList) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.OperatorKeyword, this.Type, parameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
+        public new ConversionOperatorDeclarationSyntax WithParameterList(ParameterListSyntax parameterList) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.Type, parameterList, this.Body, this.ExpressionBody, this.SemicolonToken);
         internal override BaseMethodDeclarationSyntax WithBodyCore(BlockSyntax? body) => WithBody(body);
-        public new ConversionOperatorDeclarationSyntax WithBody(BlockSyntax? body) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.OperatorKeyword, this.Type, this.ParameterList, body, this.ExpressionBody, this.SemicolonToken);
+        public new ConversionOperatorDeclarationSyntax WithBody(BlockSyntax? body) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.Type, this.ParameterList, body, this.ExpressionBody, this.SemicolonToken);
         internal override BaseMethodDeclarationSyntax WithExpressionBodyCore(ArrowExpressionClauseSyntax? expressionBody) => WithExpressionBody(expressionBody);
-        public new ConversionOperatorDeclarationSyntax WithExpressionBody(ArrowExpressionClauseSyntax? expressionBody) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, expressionBody, this.SemicolonToken);
+        public new ConversionOperatorDeclarationSyntax WithExpressionBody(ArrowExpressionClauseSyntax? expressionBody) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, expressionBody, this.SemicolonToken);
         internal override BaseMethodDeclarationSyntax WithSemicolonTokenCore(SyntaxToken semicolonToken) => WithSemicolonToken(semicolonToken);
-        public new ConversionOperatorDeclarationSyntax WithSemicolonToken(SyntaxToken semicolonToken) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, semicolonToken);
+        public new ConversionOperatorDeclarationSyntax WithSemicolonToken(SyntaxToken semicolonToken) => Update(this.AttributeLists, this.Modifiers, this.ImplicitOrExplicitKeyword, this.ExplicitInterfaceSpecifier, this.OperatorKeyword, this.Type, this.ParameterList, this.Body, this.ExpressionBody, semicolonToken);
 
         internal override MemberDeclarationSyntax AddAttributeListsCore(params AttributeListSyntax[] items) => AddAttributeLists(items);
         public new ConversionOperatorDeclarationSyntax AddAttributeLists(params AttributeListSyntax[] items) => WithAttributeLists(this.AttributeLists.AddRange(items));
@@ -15120,13 +15138,32 @@ public UndefDirectiveTriviaSyntax Update(SyntaxToken hashToken, SyntaxToken unde
         public UndefDirectiveTriviaSyntax WithIsActive(bool isActive) => Update(this.HashToken, this.UndefKeyword, this.Name, this.EndOfDirectiveToken, isActive);
     }
 
+    public abstract partial class LineOrSpanDirectiveTriviaSyntax : DirectiveTriviaSyntax
+    {
+        internal LineOrSpanDirectiveTriviaSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position)
+          : base(green, parent, position)
+        {
+        }
+
+        public abstract SyntaxToken LineKeyword { get; }
+        public LineOrSpanDirectiveTriviaSyntax WithLineKeyword(SyntaxToken lineKeyword) => WithLineKeywordCore(lineKeyword);
+        internal abstract LineOrSpanDirectiveTriviaSyntax WithLineKeywordCore(SyntaxToken lineKeyword);
+
+        public abstract SyntaxToken File { get; }
+        public LineOrSpanDirectiveTriviaSyntax WithFile(SyntaxToken file) => WithFileCore(file);
+        internal abstract LineOrSpanDirectiveTriviaSyntax WithFileCore(SyntaxToken file);
+
+        public new LineOrSpanDirectiveTriviaSyntax WithHashToken(SyntaxToken hashToken) => (LineOrSpanDirectiveTriviaSyntax)WithHashTokenCore(hashToken);
+        public new LineOrSpanDirectiveTriviaSyntax WithEndOfDirectiveToken(SyntaxToken endOfDirectiveToken) => (LineOrSpanDirectiveTriviaSyntax)WithEndOfDirectiveTokenCore(endOfDirectiveToken);
+    }
+
     /// <remarks>
     /// <para>This node is associated with the following syntax kinds:</para>
     /// <list type="bullet">
     /// <item><description><see cref="SyntaxKind.LineDirectiveTrivia"/></description></item>
     /// </list>
     /// </remarks>
-    public sealed partial class LineDirectiveTriviaSyntax : DirectiveTriviaSyntax
+    public sealed partial class LineDirectiveTriviaSyntax : LineOrSpanDirectiveTriviaSyntax
     {
 
         internal LineDirectiveTriviaSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position)
@@ -15136,11 +15173,11 @@ internal LineDirectiveTriviaSyntax(InternalSyntax.CSharpSyntaxNode green, Syntax
 
         public override SyntaxToken HashToken => new SyntaxToken(this, ((Syntax.InternalSyntax.LineDirectiveTriviaSyntax)this.Green).hashToken, Position, 0);
 
-        public SyntaxToken LineKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.LineDirectiveTriviaSyntax)this.Green).lineKeyword, GetChildPosition(1), GetChildIndex(1));
+        public override SyntaxToken LineKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.LineDirectiveTriviaSyntax)this.Green).lineKeyword, GetChildPosition(1), GetChildIndex(1));
 
         public SyntaxToken Line => new SyntaxToken(this, ((Syntax.InternalSyntax.LineDirectiveTriviaSyntax)this.Green).line, GetChildPosition(2), GetChildIndex(2));
 
-        public SyntaxToken File
+        public override SyntaxToken File
         {
             get
             {
@@ -15174,14 +15211,153 @@ public LineDirectiveTriviaSyntax Update(SyntaxToken hashToken, SyntaxToken lineK
 
         internal override DirectiveTriviaSyntax WithHashTokenCore(SyntaxToken hashToken) => WithHashToken(hashToken);
         public new LineDirectiveTriviaSyntax WithHashToken(SyntaxToken hashToken) => Update(hashToken, this.LineKeyword, this.Line, this.File, this.EndOfDirectiveToken, this.IsActive);
-        public LineDirectiveTriviaSyntax WithLineKeyword(SyntaxToken lineKeyword) => Update(this.HashToken, lineKeyword, this.Line, this.File, this.EndOfDirectiveToken, this.IsActive);
+        internal override LineOrSpanDirectiveTriviaSyntax WithLineKeywordCore(SyntaxToken lineKeyword) => WithLineKeyword(lineKeyword);
+        public new LineDirectiveTriviaSyntax WithLineKeyword(SyntaxToken lineKeyword) => Update(this.HashToken, lineKeyword, this.Line, this.File, this.EndOfDirectiveToken, this.IsActive);
         public LineDirectiveTriviaSyntax WithLine(SyntaxToken line) => Update(this.HashToken, this.LineKeyword, line, this.File, this.EndOfDirectiveToken, this.IsActive);
-        public LineDirectiveTriviaSyntax WithFile(SyntaxToken file) => Update(this.HashToken, this.LineKeyword, this.Line, file, this.EndOfDirectiveToken, this.IsActive);
+        internal override LineOrSpanDirectiveTriviaSyntax WithFileCore(SyntaxToken file) => WithFile(file);
+        public new LineDirectiveTriviaSyntax WithFile(SyntaxToken file) => Update(this.HashToken, this.LineKeyword, this.Line, file, this.EndOfDirectiveToken, this.IsActive);
         internal override DirectiveTriviaSyntax WithEndOfDirectiveTokenCore(SyntaxToken endOfDirectiveToken) => WithEndOfDirectiveToken(endOfDirectiveToken);
         public new LineDirectiveTriviaSyntax WithEndOfDirectiveToken(SyntaxToken endOfDirectiveToken) => Update(this.HashToken, this.LineKeyword, this.Line, this.File, endOfDirectiveToken, this.IsActive);
         public LineDirectiveTriviaSyntax WithIsActive(bool isActive) => Update(this.HashToken, this.LineKeyword, this.Line, this.File, this.EndOfDirectiveToken, isActive);
     }
 
+    /// <remarks>
+    /// <para>This node is associated with the following syntax kinds:</para>
+    /// <list type="bullet">
+    /// <item><description><see cref="SyntaxKind.LineDirectivePosition"/></description></item>
+    /// </list>
+    /// </remarks>
+    public sealed partial class LineDirectivePositionSyntax : CSharpSyntaxNode
+    {
+
+        internal LineDirectivePositionSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position)
+          : base(green, parent, position)
+        {
+        }
+
+        public SyntaxToken OpenParenToken => new SyntaxToken(this, ((Syntax.InternalSyntax.LineDirectivePositionSyntax)this.Green).openParenToken, Position, 0);
+
+        public SyntaxToken Line => new SyntaxToken(this, ((Syntax.InternalSyntax.LineDirectivePositionSyntax)this.Green).line, GetChildPosition(1), GetChildIndex(1));
+
+        public SyntaxToken CommaToken => new SyntaxToken(this, ((Syntax.InternalSyntax.LineDirectivePositionSyntax)this.Green).commaToken, GetChildPosition(2), GetChildIndex(2));
+
+        public SyntaxToken Character => new SyntaxToken(this, ((Syntax.InternalSyntax.LineDirectivePositionSyntax)this.Green).character, GetChildPosition(3), GetChildIndex(3));
+
+        public SyntaxToken CloseParenToken => new SyntaxToken(this, ((Syntax.InternalSyntax.LineDirectivePositionSyntax)this.Green).closeParenToken, GetChildPosition(4), GetChildIndex(4));
+
+        internal override SyntaxNode? GetNodeSlot(int index) => null;
+
+        internal override SyntaxNode? GetCachedSlot(int index) => null;
+
+        public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitLineDirectivePosition(this);
+        public override TResult? Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) where TResult : default => visitor.VisitLineDirectivePosition(this);
+
+        public LineDirectivePositionSyntax Update(SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken)
+        {
+            if (openParenToken != this.OpenParenToken || line != this.Line || commaToken != this.CommaToken || character != this.Character || closeParenToken != this.CloseParenToken)
+            {
+                var newNode = SyntaxFactory.LineDirectivePosition(openParenToken, line, commaToken, character, closeParenToken);
+                var annotations = GetAnnotations();
+                return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode;
+            }
+
+            return this;
+        }
+
+        public LineDirectivePositionSyntax WithOpenParenToken(SyntaxToken openParenToken) => Update(openParenToken, this.Line, this.CommaToken, this.Character, this.CloseParenToken);
+        public LineDirectivePositionSyntax WithLine(SyntaxToken line) => Update(this.OpenParenToken, line, this.CommaToken, this.Character, this.CloseParenToken);
+        public LineDirectivePositionSyntax WithCommaToken(SyntaxToken commaToken) => Update(this.OpenParenToken, this.Line, commaToken, this.Character, this.CloseParenToken);
+        public LineDirectivePositionSyntax WithCharacter(SyntaxToken character) => Update(this.OpenParenToken, this.Line, this.CommaToken, character, this.CloseParenToken);
+        public LineDirectivePositionSyntax WithCloseParenToken(SyntaxToken closeParenToken) => Update(this.OpenParenToken, this.Line, this.CommaToken, this.Character, closeParenToken);
+    }
+
+    /// <remarks>
+    /// <para>This node is associated with the following syntax kinds:</para>
+    /// <list type="bullet">
+    /// <item><description><see cref="SyntaxKind.LineSpanDirectiveTrivia"/></description></item>
+    /// </list>
+    /// </remarks>
+    public sealed partial class LineSpanDirectiveTriviaSyntax : LineOrSpanDirectiveTriviaSyntax
+    {
+        private LineDirectivePositionSyntax? start;
+        private LineDirectivePositionSyntax? end;
+
+        internal LineSpanDirectiveTriviaSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position)
+          : base(green, parent, position)
+        {
+        }
+
+        public override SyntaxToken HashToken => new SyntaxToken(this, ((Syntax.InternalSyntax.LineSpanDirectiveTriviaSyntax)this.Green).hashToken, Position, 0);
+
+        public override SyntaxToken LineKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.LineSpanDirectiveTriviaSyntax)this.Green).lineKeyword, GetChildPosition(1), GetChildIndex(1));
+
+        public LineDirectivePositionSyntax Start => GetRed(ref this.start, 2)!;
+
+        public SyntaxToken MinusToken => new SyntaxToken(this, ((Syntax.InternalSyntax.LineSpanDirectiveTriviaSyntax)this.Green).minusToken, GetChildPosition(3), GetChildIndex(3));
+
+        public LineDirectivePositionSyntax End => GetRed(ref this.end, 4)!;
+
+        public SyntaxToken CharacterOffset
+        {
+            get
+            {
+                var slot = ((Syntax.InternalSyntax.LineSpanDirectiveTriviaSyntax)this.Green).characterOffset;
+                return slot != null ? new SyntaxToken(this, slot, GetChildPosition(5), GetChildIndex(5)) : default;
+            }
+        }
+
+        public override SyntaxToken File => new SyntaxToken(this, ((Syntax.InternalSyntax.LineSpanDirectiveTriviaSyntax)this.Green).file, GetChildPosition(6), GetChildIndex(6));
+
+        public override SyntaxToken EndOfDirectiveToken => new SyntaxToken(this, ((Syntax.InternalSyntax.LineSpanDirectiveTriviaSyntax)this.Green).endOfDirectiveToken, GetChildPosition(7), GetChildIndex(7));
+
+        public override bool IsActive => ((Syntax.InternalSyntax.LineSpanDirectiveTriviaSyntax)this.Green).IsActive;
+
+        internal override SyntaxNode? GetNodeSlot(int index)
+            => index switch
+            {
+                2 => GetRed(ref this.start, 2)!,
+                4 => GetRed(ref this.end, 4)!,
+                _ => null,
+            };
+
+        internal override SyntaxNode? GetCachedSlot(int index)
+            => index switch
+            {
+                2 => this.start,
+                4 => this.end,
+                _ => null,
+            };
+
+        public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitLineSpanDirectiveTrivia(this);
+        public override TResult? Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor) where TResult : default => visitor.VisitLineSpanDirectiveTrivia(this);
+
+        public LineSpanDirectiveTriviaSyntax Update(SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
+        {
+            if (hashToken != this.HashToken || lineKeyword != this.LineKeyword || start != this.Start || minusToken != this.MinusToken || end != this.End || characterOffset != this.CharacterOffset || file != this.File || endOfDirectiveToken != this.EndOfDirectiveToken)
+            {
+                var newNode = SyntaxFactory.LineSpanDirectiveTrivia(hashToken, lineKeyword, start, minusToken, end, characterOffset, file, endOfDirectiveToken, isActive);
+                var annotations = GetAnnotations();
+                return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode;
+            }
+
+            return this;
+        }
+
+        internal override DirectiveTriviaSyntax WithHashTokenCore(SyntaxToken hashToken) => WithHashToken(hashToken);
+        public new LineSpanDirectiveTriviaSyntax WithHashToken(SyntaxToken hashToken) => Update(hashToken, this.LineKeyword, this.Start, this.MinusToken, this.End, this.CharacterOffset, this.File, this.EndOfDirectiveToken, this.IsActive);
+        internal override LineOrSpanDirectiveTriviaSyntax WithLineKeywordCore(SyntaxToken lineKeyword) => WithLineKeyword(lineKeyword);
+        public new LineSpanDirectiveTriviaSyntax WithLineKeyword(SyntaxToken lineKeyword) => Update(this.HashToken, lineKeyword, this.Start, this.MinusToken, this.End, this.CharacterOffset, this.File, this.EndOfDirectiveToken, this.IsActive);
+        public LineSpanDirectiveTriviaSyntax WithStart(LineDirectivePositionSyntax start) => Update(this.HashToken, this.LineKeyword, start, this.MinusToken, this.End, this.CharacterOffset, this.File, this.EndOfDirectiveToken, this.IsActive);
+        public LineSpanDirectiveTriviaSyntax WithMinusToken(SyntaxToken minusToken) => Update(this.HashToken, this.LineKeyword, this.Start, minusToken, this.End, this.CharacterOffset, this.File, this.EndOfDirectiveToken, this.IsActive);
+        public LineSpanDirectiveTriviaSyntax WithEnd(LineDirectivePositionSyntax end) => Update(this.HashToken, this.LineKeyword, this.Start, this.MinusToken, end, this.CharacterOffset, this.File, this.EndOfDirectiveToken, this.IsActive);
+        public LineSpanDirectiveTriviaSyntax WithCharacterOffset(SyntaxToken characterOffset) => Update(this.HashToken, this.LineKeyword, this.Start, this.MinusToken, this.End, characterOffset, this.File, this.EndOfDirectiveToken, this.IsActive);
+        internal override LineOrSpanDirectiveTriviaSyntax WithFileCore(SyntaxToken file) => WithFile(file);
+        public new LineSpanDirectiveTriviaSyntax WithFile(SyntaxToken file) => Update(this.HashToken, this.LineKeyword, this.Start, this.MinusToken, this.End, this.CharacterOffset, file, this.EndOfDirectiveToken, this.IsActive);
+        internal override DirectiveTriviaSyntax WithEndOfDirectiveTokenCore(SyntaxToken endOfDirectiveToken) => WithEndOfDirectiveToken(endOfDirectiveToken);
+        public new LineSpanDirectiveTriviaSyntax WithEndOfDirectiveToken(SyntaxToken endOfDirectiveToken) => Update(this.HashToken, this.LineKeyword, this.Start, this.MinusToken, this.End, this.CharacterOffset, this.File, endOfDirectiveToken, this.IsActive);
+        public LineSpanDirectiveTriviaSyntax WithIsActive(bool isActive) => Update(this.HashToken, this.LineKeyword, this.Start, this.MinusToken, this.End, this.CharacterOffset, this.File, this.EndOfDirectiveToken, isActive);
+    }
+
     /// <remarks>
     /// <para>This node is associated with the following syntax kinds:</para>
     /// <list type="bullet">
diff --git a/src/Compilers/CSharp/Portable/Generated/ErrorFacts.Generated.cs b/src/Compilers/CSharp/Portable/Generated/ErrorFacts.Generated.cs
index bc352ddede0c2..025c4df32f81b 100644
--- a/src/Compilers/CSharp/Portable/Generated/ErrorFacts.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/ErrorFacts.Generated.cs
@@ -310,6 +310,7 @@ public static bool IsHidden(ErrorCode code)
             {
                 case ErrorCode.HDN_UnusedUsingDirective:
                 case ErrorCode.HDN_UnusedExternAlias:
+                case ErrorCode.HDN_DuplicateWithGlobalUsing:
                     return true;
                 default:
                     return false;
diff --git a/src/Compilers/CSharp/Portable/LanguageVersion.cs b/src/Compilers/CSharp/Portable/LanguageVersion.cs
index 4b7aff7955dad..cc0d508de5d28 100644
--- a/src/Compilers/CSharp/Portable/LanguageVersion.cs
+++ b/src/Compilers/CSharp/Portable/LanguageVersion.cs
@@ -187,6 +187,26 @@ public enum LanguageVersion
         /// </remarks>
         CSharp9 = 900,
 
+        /// <summary>
+        /// C# language version 10.0
+        /// </summary>
+        /// <remarks>
+        /// <para>Features:</para>
+        /// <list type="bullet">
+        /// <item><description>Record structs</description></item>
+        /// <item><description>Global using directives</description></item>
+        /// <item><description>Lambda improvements</description></item>
+        /// <item><description>Improved definite assignment</description></item>
+        /// <item><description>Constant interpolated strings</description></item>
+        /// <item><description>Mix declarations and variables in deconstruction</description></item>
+        /// <item><description>Extended property patterns</description></item>
+        /// <item><description>Sealed record ToString</description></item>
+        /// <item><description>Source Generator v2 APIs</description></item>
+        /// <item><description>Method-level AsyncMethodBuilder</description></item>
+        /// </list>
+        /// </remarks>
+        CSharp10 = 1000,
+
         /// <summary>
         /// The latest major supported version.
         /// </summary>
@@ -226,6 +246,7 @@ internal static bool IsValid(this LanguageVersion value)
                 case LanguageVersion.CSharp7_3:
                 case LanguageVersion.CSharp8:
                 case LanguageVersion.CSharp9:
+                case LanguageVersion.CSharp10:
                 case LanguageVersion.Preview:
                     return true;
             }
@@ -261,6 +282,8 @@ internal static ErrorCode GetErrorCode(this LanguageVersion version)
                     return ErrorCode.ERR_FeatureNotAvailableInVersion8;
                 case LanguageVersion.CSharp9:
                     return ErrorCode.ERR_FeatureNotAvailableInVersion9;
+                case LanguageVersion.CSharp10:
+                    return ErrorCode.ERR_FeatureNotAvailableInVersion10;
                 default:
                     throw ExceptionUtilities.UnexpectedValue(version);
             }
@@ -281,6 +304,12 @@ internal CSharpRequiredLanguageVersion(LanguageVersion version)
 
     public static class LanguageVersionFacts
     {
+        /// <summary>
+        /// Usages of TestOptions.RegularNext and LanguageVersionFacts.CSharpNext
+        /// will be replaced with TestOptions.RegularN and LanguageVersion.CSharpN when language version N is introduced.
+        /// </summary>
+        internal const LanguageVersion CSharpNext = LanguageVersion.Preview;
+
         /// <summary>
         /// Displays the version number in the format expected on the command-line (/langver flag).
         /// For instance, "6", "7.0", "7.1", "latest".
@@ -313,6 +342,8 @@ public static string ToDisplayString(this LanguageVersion version)
                     return "8.0";
                 case LanguageVersion.CSharp9:
                     return "9.0";
+                case LanguageVersion.CSharp10:
+                    return "10.0";
                 case LanguageVersion.Default:
                     return "default";
                 case LanguageVersion.Latest:
@@ -414,6 +445,11 @@ public static bool TryParse(string? version, out LanguageVersion result)
                     result = LanguageVersion.CSharp9;
                     return true;
 
+                case "10":
+                case "10.0":
+                    result = LanguageVersion.CSharp10;
+                    return true;
+
                 default:
                     result = LanguageVersion.Default;
                     return false;
@@ -430,13 +466,13 @@ public static LanguageVersion MapSpecifiedToEffectiveVersion(this LanguageVersio
                 case LanguageVersion.Latest:
                 case LanguageVersion.Default:
                 case LanguageVersion.LatestMajor:
-                    return LanguageVersion.CSharp9;
+                    return LanguageVersion.CSharp10;
                 default:
                     return version;
             }
         }
 
-        internal static LanguageVersion CurrentVersion => LanguageVersion.CSharp9;
+        internal static LanguageVersion CurrentVersion => LanguageVersion.CSharp10;
 
         /// <summary>Inference of tuple element names was added in C# 7.1</summary>
         internal static bool DisallowInferredTupleElementNames(this LanguageVersion self)
diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodBuilderMemberCollection.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodBuilderMemberCollection.cs
index f2d72b5841fdf..088bf7dc188a1 100644
--- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodBuilderMemberCollection.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodBuilderMemberCollection.cs
@@ -159,7 +159,7 @@ internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method,
                     out createBuilderMethod);
                 if ((object)createBuilderMethod == null)
                 {
-                    collection = default(AsyncMethodBuilderMemberCollection);
+                    collection = default;
                     return false;
                 }
                 return TryCreate(
@@ -178,18 +178,30 @@ internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method,
                     collection: out collection);
             }
 
-            if (method.IsAsyncReturningTask(F.Compilation))
+            object methodLevelBuilder = null;
+            if (method.IsAsyncEffectivelyReturningTask(F.Compilation))
             {
                 var returnType = (NamedTypeSymbol)method.ReturnType;
                 NamedTypeSymbol builderType;
                 MethodSymbol createBuilderMethod = null;
                 PropertySymbol taskProperty = null;
-
+                bool useMethodLevelBuilder = method.HasAsyncMethodBuilderAttribute(out methodLevelBuilder);
+                bool customBuilder;
                 object builderArgument;
-                bool customBuilder = returnType.IsCustomTaskType(out builderArgument);
+
+                if (useMethodLevelBuilder)
+                {
+                    customBuilder = true;
+                    builderArgument = methodLevelBuilder;
+                }
+                else
+                {
+                    customBuilder = returnType.IsCustomTaskType(out builderArgument);
+                }
+
                 if (customBuilder)
                 {
-                    builderType = ValidateBuilderType(F, builderArgument, returnType.DeclaredAccessibility, isGeneric: false);
+                    builderType = ValidateBuilderType(F, builderArgument, returnType.DeclaredAccessibility, isGeneric: false, useMethodLevelBuilder);
                     if ((object)builderType != null)
                     {
                         taskProperty = GetCustomTaskProperty(F, builderType, returnType);
@@ -213,13 +225,15 @@ internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method,
                         customBuilder,
                         out taskProperty);
                 }
+
                 if ((object)builderType == null ||
                     (object)createBuilderMethod == null ||
                     (object)taskProperty == null)
                 {
-                    collection = default(AsyncMethodBuilderMemberCollection);
+                    collection = default;
                     return false;
                 }
+
                 return TryCreate(
                     F,
                     customBuilder: customBuilder,
@@ -236,7 +250,7 @@ internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method,
                     collection: out collection);
             }
 
-            if (method.IsAsyncReturningGenericTask(F.Compilation))
+            if (method.IsAsyncEffectivelyReturningGenericTask(F.Compilation))
             {
                 var returnType = (NamedTypeSymbol)method.ReturnType;
                 var resultType = returnType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type;
@@ -252,12 +266,23 @@ internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method,
                 NamedTypeSymbol builderType;
                 MethodSymbol createBuilderMethod = null;
                 PropertySymbol taskProperty = null;
-
+                bool useMethodLevelBuilder = method.HasAsyncMethodBuilderAttribute(out methodLevelBuilder);
+                bool customBuilder;
                 object builderArgument;
-                bool customBuilder = returnType.IsCustomTaskType(out builderArgument);
+
+                if (useMethodLevelBuilder)
+                {
+                    customBuilder = true;
+                    builderArgument = methodLevelBuilder;
+                }
+                else
+                {
+                    customBuilder = returnType.IsCustomTaskType(out builderArgument);
+                }
+
                 if (customBuilder)
                 {
-                    builderType = ValidateBuilderType(F, builderArgument, returnType.DeclaredAccessibility, isGeneric: true);
+                    builderType = ValidateBuilderType(F, builderArgument, returnType.DeclaredAccessibility, isGeneric: true, useMethodLevelBuilder);
                     if ((object)builderType != null)
                     {
                         builderType = builderType.ConstructedFrom.Construct(resultType);
@@ -283,13 +308,15 @@ internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method,
                         customBuilder,
                         out taskProperty);
                 }
+
                 if ((object)builderType == null ||
                     (object)taskProperty == null ||
                     (object)createBuilderMethod == null)
                 {
-                    collection = default(AsyncMethodBuilderMemberCollection);
+                    collection = default;
                     return false;
                 }
+
                 return TryCreate(
                     F,
                     customBuilder: customBuilder,
@@ -309,19 +336,29 @@ internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method,
             throw ExceptionUtilities.UnexpectedValue(method);
         }
 
-        private static NamedTypeSymbol ValidateBuilderType(SyntheticBoundNodeFactory F, object builderAttributeArgument, Accessibility desiredAccessibility, bool isGeneric)
+        private static NamedTypeSymbol ValidateBuilderType(SyntheticBoundNodeFactory F, object builderAttributeArgument, Accessibility desiredAccessibility, bool isGeneric, bool forMethodLevelBuilder = false)
         {
             var builderType = builderAttributeArgument as NamedTypeSymbol;
 
             if ((object)builderType != null &&
                  !builderType.IsErrorType() &&
                  !builderType.IsVoidType() &&
-                 builderType.DeclaredAccessibility == desiredAccessibility)
+                 (forMethodLevelBuilder || builderType.DeclaredAccessibility == desiredAccessibility))
             {
-                bool isArityOk = isGeneric
-                                 ? builderType.IsUnboundGenericType && builderType.ContainingType?.IsGenericType != true && builderType.Arity == 1
-                                 : !builderType.IsGenericType;
-                if (isArityOk)
+                if (isGeneric)
+                {
+                    if (builderType.IsUnboundGenericType && builderType.ContainingType?.IsGenericType != true && builderType.Arity == 1)
+                    {
+                        return builderType;
+                    }
+                    else
+                    {
+                        F.Diagnostics.Add(ErrorCode.ERR_WrongArityAsyncReturn, F.Syntax.Location, builderType);
+                        return null;
+                    }
+                }
+
+                if (!builderType.IsGenericType)
                 {
                     return builderType;
                 }
@@ -376,7 +413,7 @@ private static bool TryCreate(
                 return true;
             }
 
-            collection = default(AsyncMethodBuilderMemberCollection);
+            collection = default;
             return false;
         }
 
@@ -448,6 +485,7 @@ private static MethodSymbol GetCustomCreateMethod(
                     method.IsStatic &&
                     method.ParameterCount == 0 &&
                     !method.IsGenericMethod &&
+                    method.RefKind == RefKind.None &&
                     method.ReturnType.Equals(builderType, TypeCompareKind.AllIgnoreOptions))
                 {
                     return method;
diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs
index d0a1e0d94bdfc..de5d554e25fa2 100644
--- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs
@@ -85,7 +85,7 @@ internal AsyncMethodToStateMachineRewriter(
             _exprReturnLabel = F.GenerateLabel("exprReturn");
             _exitLabel = F.GenerateLabel("exitLabel");
 
-            _exprRetValue = method.IsAsyncReturningGenericTask(F.Compilation)
+            _exprRetValue = method.IsAsyncEffectivelyReturningGenericTask(F.Compilation)
                 ? F.SynthesizedLocal(asyncMethodBuilderMemberCollection.ResultType, syntax: F.Syntax, kind: SynthesizedLocalKind.AsyncMethodReturnValue)
                 : null;
 
@@ -208,7 +208,7 @@ protected virtual BoundStatement GenerateSetResultCall()
                 F.Call(
                     F.Field(F.This(), _asyncMethodBuilderField),
                     _asyncMethodBuilderMemberCollection.SetResult,
-                    _method.IsAsyncReturningGenericTask(F.Compilation)
+                    _method.IsAsyncEffectivelyReturningGenericTask(F.Compilation)
                         ? ImmutableArray.Create<BoundExpression>(F.Local(_exprRetValue))
                         : ImmutableArray<BoundExpression>.Empty));
         }
@@ -623,7 +623,7 @@ public sealed override BoundNode VisitReturnStatement(BoundReturnStatement node)
         {
             if (node.ExpressionOpt != null)
             {
-                Debug.Assert(_method.IsAsyncReturningGenericTask(F.Compilation));
+                Debug.Assert(_method.IsAsyncEffectivelyReturningGenericTask(F.Compilation));
                 return F.Block(
                     F.Assignment(F.Local(_exprRetValue), (BoundExpression)Visit(node.ExpressionOpt)),
                     F.Goto(_exprReturnLabel));
diff --git a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs
index 6f7b0452390e3..2d740407edaf5 100644
--- a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs
@@ -1334,7 +1334,7 @@ public override BoundNode VisitFunctionPointerLoad(BoundFunctionPointerLoad node
                              receiver.Kind == BoundKind.TypeExpression &&
                              remappedMethod is { RequiresInstanceReceiver: false, IsStatic: true });
 
-                return node.Update(remappedMethod, node.Type);
+                return node.Update(remappedMethod, constrainedToTypeOpt: node.ConstrainedToTypeOpt, node.Type);
             }
 
             return base.VisitFunctionPointerLoad(node);
diff --git a/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs b/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs
index 0e381b86a9313..28c3aee2fa628 100644
--- a/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs
@@ -335,6 +335,10 @@ private void VisitCall(
                 {
                     Error(ErrorCode.ERR_RefReturningCallInExpressionTree, node);
                 }
+                else if (method.IsAbstract && method.IsStatic)
+                {
+                    Error(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, node);
+                }
             }
 
             static bool hasDefaultArgument(ImmutableArray<BoundExpression> arguments, BitVector defaultArguments)
@@ -499,6 +503,12 @@ public override BoundNode VisitPropertyAccess(BoundPropertyAccess node)
             var property = node.PropertySymbol;
             CheckRefReturningPropertyAccess(node, property);
             CheckReceiverIfField(node.ReceiverOpt);
+
+            if (_inExpressionLambda && property.IsAbstract && property.IsStatic)
+            {
+                Error(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, node);
+            }
+
             return base.VisitPropertyAccess(node);
         }
 
@@ -610,6 +620,18 @@ public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)
         public override BoundNode VisitUserDefinedConditionalLogicalOperator(BoundUserDefinedConditionalLogicalOperator node)
         {
             CheckLiftedUserDefinedConditionalLogicalOperator(node);
+
+            if (_inExpressionLambda)
+            {
+                var binary = node.LogicalOperator;
+                var unary = node.OperatorKind.Operator() == BinaryOperatorKind.And ? node.FalseOperator : node.TrueOperator;
+
+                if ((binary.IsAbstract && binary.IsStatic) || (unary.IsAbstract && unary.IsStatic))
+                {
+                    Error(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, node);
+                }
+            }
+
             return base.VisitUserDefinedConditionalLogicalOperator(node);
         }
 
@@ -634,6 +656,12 @@ public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
             CheckUnsafeType(node);
             CheckLiftedUnaryOp(node);
             CheckDynamic(node);
+
+            if (_inExpressionLambda && node.MethodOpt is MethodSymbol method && method.IsAbstract && method.IsStatic)
+            {
+                Error(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, node);
+            }
+
             return base.VisitUnaryOperator(node);
         }
 
@@ -718,6 +746,11 @@ public override BoundNode VisitConversion(BoundConversion node)
                     break;
 
                 default:
+
+                    if (_inExpressionLambda && node.Conversion.Method is MethodSymbol method && method.IsAbstract && method.IsStatic)
+                    {
+                        Error(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, node);
+                    }
                     break;
             }
 
@@ -764,6 +797,10 @@ private void CheckMethodGroup(BoundMethodGroup node, MethodSymbol method, bool p
                 {
                     Error(ErrorCode.ERR_AddressOfMethodGroupInExpressionTree, node);
                 }
+                else if (method is not null && method.IsAbstract && method.IsStatic)
+                {
+                    Error(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, node);
+                }
             }
 
             CheckReceiverIfField(node.ReceiverOpt);
diff --git a/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_Warnings.cs b/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_Warnings.cs
index cb2a4da40db6f..78e98f7da87ef 100644
--- a/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_Warnings.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_Warnings.cs
@@ -249,7 +249,14 @@ private static bool IsComCallWithRefOmitted(MethodSymbol method, ImmutableArray<
 
         private void CheckBinaryOperator(BoundBinaryOperator node)
         {
-            if ((object)node.MethodOpt == null)
+            if (node.MethodOpt is MethodSymbol method)
+            {
+                if (_inExpressionLambda && method.IsAbstract && method.IsStatic)
+                {
+                    Error(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, node);
+                }
+            }
+            else
             {
                 CheckUnsafeType(node.Left);
                 CheckUnsafeType(node.Right);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.PatternLocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.PatternLocalRewriter.cs
index 2e9987e2107b6..dac9b08a94ac0 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.PatternLocalRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.PatternLocalRewriter.cs
@@ -296,7 +296,7 @@ private BoundExpression MakeNullCheck(SyntaxNode syntax, BoundExpression rewritt
                         _factory.Convert(operandType, rewrittenExpr),
                         _factory.Convert(operandType, new BoundLiteral(syntax, ConstantValue.Null, objectType)),
                         _factory.SpecialType(SpecialType.System_Boolean),
-                        null);
+                        method: null, constrainedToTypeOpt: null);
                 }
 
                 return _localRewriter.MakeNullCheck(syntax, rewrittenExpr, operatorKind);
@@ -338,7 +338,7 @@ protected BoundExpression MakeRelationalTest(SyntaxNode syntax, BoundExpression
                     literal = _factory.Convert(comparisonType, literal);
                 }
 
-                return this._localRewriter.MakeBinaryOperator(_factory.Syntax, operatorKind, input, literal, _factory.SpecialType(SpecialType.System_Boolean), method: null);
+                return this._localRewriter.MakeBinaryOperator(_factory.Syntax, operatorKind, input, literal, _factory.SpecialType(SpecialType.System_Boolean), method: null, constrainedToTypeOpt: null);
             }
 
             /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
index f98b83f1b36c5..82d8398964970 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
@@ -77,17 +77,18 @@ public override BoundNode VisitUserDefinedConditionalLogicalOperator(BoundUserDe
 
             if (_inExpressionLambda)
             {
-                return node.Update(operatorKind, node.LogicalOperator, node.TrueOperator, node.FalseOperator, node.ResultKind, loweredLeft, loweredRight, type);
+                return node.Update(operatorKind, node.LogicalOperator, node.TrueOperator, node.FalseOperator, node.ConstrainedToTypeOpt, node.ResultKind, loweredLeft, loweredRight, type);
             }
 
             BoundAssignmentOperator tempAssignment;
             var boundTemp = _factory.StoreToTemp(loweredLeft, out tempAssignment);
 
             // T.false(temp)
-            var falseOperatorCall = BoundCall.Synthesized(syntax, receiverOpt: null, operatorKind.Operator() == BinaryOperatorKind.And ? node.FalseOperator : node.TrueOperator, boundTemp);
+            var falseOperatorCall = BoundCall.Synthesized(syntax, receiverOpt: node.ConstrainedToTypeOpt is null ? null : new BoundTypeExpression(syntax, aliasOpt: null, node.ConstrainedToTypeOpt),
+                                                          operatorKind.Operator() == BinaryOperatorKind.And ? node.FalseOperator : node.TrueOperator, boundTemp);
 
             // T.&(temp, y)
-            var andOperatorCall = LowerUserDefinedBinaryOperator(syntax, operatorKind & ~BinaryOperatorKind.Logical, boundTemp, loweredRight, type, node.LogicalOperator);
+            var andOperatorCall = LowerUserDefinedBinaryOperator(syntax, operatorKind & ~BinaryOperatorKind.Logical, boundTemp, loweredRight, type, node.LogicalOperator, node.ConstrainedToTypeOpt);
 
             // T.false(temp) ? temp : T.&(temp, y)
             BoundExpression conditionalExpression = RewriteConditionalOperator(
@@ -127,7 +128,7 @@ public BoundExpression VisitBinaryOperator(BoundBinaryOperator node, BoundUnaryO
             {
                 BoundBinaryOperator original = stack.Pop();
                 BoundExpression loweredRight = VisitExpression(original.Right);
-                loweredLeft = MakeBinaryOperator(original, original.Syntax, original.OperatorKind, loweredLeft, loweredRight, original.Type, original.MethodOpt,
+                loweredLeft = MakeBinaryOperator(original, original.Syntax, original.OperatorKind, loweredLeft, loweredRight, original.Type, original.MethodOpt, original.ConstrainedToTypeOpt,
                     applyParentUnaryOperator: (stack.Count == 0) ? applyParentUnaryOperator : null);
             }
 
@@ -142,11 +143,12 @@ private BoundExpression MakeBinaryOperator(
             BoundExpression loweredRight,
             TypeSymbol type,
             MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt,
             bool isPointerElementAccess = false,
             bool isCompoundAssignment = false,
             BoundUnaryOperator? applyParentUnaryOperator = null)
         {
-            return MakeBinaryOperator(null, syntax, operatorKind, loweredLeft, loweredRight, type, method, isPointerElementAccess, isCompoundAssignment, applyParentUnaryOperator);
+            return MakeBinaryOperator(null, syntax, operatorKind, loweredLeft, loweredRight, type, method, constrainedToTypeOpt, isPointerElementAccess, isCompoundAssignment, applyParentUnaryOperator);
         }
 
         private BoundExpression MakeBinaryOperator(
@@ -157,6 +159,7 @@ private BoundExpression MakeBinaryOperator(
             BoundExpression loweredRight,
             TypeSymbol type,
             MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt,
             bool isPointerElementAccess = false,
             bool isCompoundAssignment = false,
             BoundUnaryOperator? applyParentUnaryOperator = null)
@@ -190,7 +193,7 @@ private BoundExpression MakeBinaryOperator(
 
                     if (operatorKind.IsLogical())
                     {
-                        return MakeDynamicLogicalBinaryOperator(syntax, operatorKind, loweredLeft, loweredRight, method, type, isCompoundAssignment, applyParentUnaryOperator);
+                        return MakeDynamicLogicalBinaryOperator(syntax, operatorKind, loweredLeft, loweredRight, method, constrainedToTypeOpt, type, isCompoundAssignment, applyParentUnaryOperator);
                     }
                     else
                     {
@@ -201,12 +204,12 @@ private BoundExpression MakeBinaryOperator(
 
                 if (operatorKind.IsLifted())
                 {
-                    return RewriteLiftedBinaryOperator(syntax, operatorKind, loweredLeft, loweredRight, type, method);
+                    return RewriteLiftedBinaryOperator(syntax, operatorKind, loweredLeft, loweredRight, type, method, constrainedToTypeOpt);
                 }
 
                 if (operatorKind.IsUserDefined())
                 {
-                    return LowerUserDefinedBinaryOperator(syntax, operatorKind, loweredLeft, loweredRight, type, method);
+                    return LowerUserDefinedBinaryOperator(syntax, operatorKind, loweredLeft, loweredRight, type, method, constrainedToTypeOpt);
                 }
 
                 switch (operatorKind.OperatorWithLogical() | operatorKind.OperandTypes())
@@ -295,10 +298,10 @@ private BoundExpression MakeBinaryOperator(
                         Debug.Assert(loweredLeft.Type is { });
                         Debug.Assert(loweredRight.Type is { });
                         if (loweredLeft.ConstantValue == ConstantValue.False)
-                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, null, loweredRight, loweredRight.Type);
+                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredRight, loweredRight.Type);
 
                         if (loweredRight.ConstantValue == ConstantValue.False)
-                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, null, loweredLeft, loweredLeft.Type);
+                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredLeft, loweredLeft.Type);
 
                         goto default;
 
@@ -309,10 +312,10 @@ private BoundExpression MakeBinaryOperator(
                         Debug.Assert(loweredLeft.Type is { });
                         Debug.Assert(loweredRight.Type is { });
                         if (loweredLeft.ConstantValue == ConstantValue.True)
-                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, null, loweredRight, loweredRight.Type);
+                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredRight, loweredRight.Type);
 
                         if (loweredRight.ConstantValue == ConstantValue.True)
-                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, null, loweredLeft, loweredLeft.Type);
+                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredLeft, loweredLeft.Type);
 
                         goto default;
 
@@ -323,10 +326,10 @@ private BoundExpression MakeBinaryOperator(
                         Debug.Assert(loweredLeft.Type is { });
                         Debug.Assert(loweredRight.Type is { });
                         if (loweredLeft.ConstantValue == ConstantValue.True)
-                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, null, loweredRight, loweredRight.Type);
+                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredRight, loweredRight.Type);
 
                         if (loweredRight.ConstantValue == ConstantValue.True)
-                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, null, loweredLeft, loweredLeft.Type);
+                            return MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, loweredLeft, loweredLeft.Type);
 
                         goto default;
 
@@ -477,11 +480,11 @@ private BoundExpression MakeBinaryOperator(
             }
 
             return (oldNode != null) ?
-                oldNode.Update(operatorKind, oldNode.ConstantValueOpt, oldNode.MethodOpt, oldNode.ResultKind, loweredLeft, loweredRight, type) :
-                new BoundBinaryOperator(syntax, operatorKind, null, null, LookupResultKind.Viable, loweredLeft, loweredRight, type);
+                oldNode.Update(operatorKind, oldNode.ConstantValueOpt, oldNode.MethodOpt, oldNode.ConstrainedToTypeOpt, oldNode.ResultKind, loweredLeft, loweredRight, type) :
+                new BoundBinaryOperator(syntax, operatorKind, constantValueOpt: null, methodOpt: null, constrainedToTypeOpt: null, LookupResultKind.Viable, loweredLeft, loweredRight, type);
         }
 
-        private BoundExpression RewriteLiftedBinaryOperator(SyntaxNode syntax, BinaryOperatorKind operatorKind, BoundExpression loweredLeft, BoundExpression loweredRight, TypeSymbol type, MethodSymbol? method)
+        private BoundExpression RewriteLiftedBinaryOperator(SyntaxNode syntax, BinaryOperatorKind operatorKind, BoundExpression loweredLeft, BoundExpression loweredRight, TypeSymbol type, MethodSymbol? method, TypeSymbol? constrainedToTypeOpt)
         {
             var conditionalLeft = loweredLeft as BoundLoweredConditionalAccess;
 
@@ -500,9 +503,9 @@ private BoundExpression RewriteLiftedBinaryOperator(SyntaxNode syntax, BinaryOpe
 
             var result = operatorKind.IsComparison() ?
                             operatorKind.IsUserDefined() ?
-                                LowerLiftedUserDefinedComparisonOperator(syntax, operatorKind, loweredLeft, loweredRight, method) :
+                                LowerLiftedUserDefinedComparisonOperator(syntax, operatorKind, loweredLeft, loweredRight, method, constrainedToTypeOpt) :
                                 LowerLiftedBuiltInComparisonOperator(syntax, operatorKind, loweredLeft, loweredRight) :
-                            LowerLiftedBinaryArithmeticOperator(syntax, operatorKind, loweredLeft, loweredRight, type, method);
+                            LowerLiftedBinaryArithmeticOperator(syntax, operatorKind, loweredLeft, loweredRight, type, method, constrainedToTypeOpt);
 
             if (optimize)
             {
@@ -514,7 +517,7 @@ private BoundExpression RewriteLiftedBinaryOperator(SyntaxNode syntax, BinaryOpe
                     operatorKind.Operator() == BinaryOperatorKind.Equal)
                 {
                     Debug.Assert(loweredLeft.Type is { });
-                    whenNullOpt = RewriteLiftedBinaryOperator(syntax, operatorKind, _factory.Default(loweredLeft.Type), loweredRight, type, method);
+                    whenNullOpt = RewriteLiftedBinaryOperator(syntax, operatorKind, _factory.Default(loweredLeft.Type), loweredRight, type, method, constrainedToTypeOpt);
                 }
 
                 result = conditionalLeft!.Update(
@@ -544,6 +547,7 @@ private BoundExpression MakeDynamicLogicalBinaryOperator(
             BoundExpression loweredLeft,
             BoundExpression loweredRight,
             MethodSymbol? leftTruthOperator,
+            TypeSymbol? constrainedToTypeOpt,
             TypeSymbol type,
             bool isCompoundAssignment,
             BoundUnaryOperator? applyParentUnaryOperator)
@@ -622,7 +626,7 @@ private BoundExpression MakeDynamicLogicalBinaryOperator(
                 result = _dynamicFactory.MakeDynamicUnaryOperator(testOperator, op, boolean).ToExpression();
                 if (!leftTestIsConstantFalse)
                 {
-                    BoundExpression leftTest = MakeTruthTestForDynamicLogicalOperator(syntax, loweredLeft, boolean, leftTruthOperator, negative: isAnd);
+                    BoundExpression leftTest = MakeTruthTestForDynamicLogicalOperator(syntax, loweredLeft, boolean, leftTruthOperator, constrainedToTypeOpt, negative: isAnd);
                     result = _factory.Binary(BinaryOperatorKind.LogicalOr, boolean, leftTest, result);
                 }
             }
@@ -638,7 +642,7 @@ private BoundExpression MakeDynamicLogicalBinaryOperator(
                 else
                 {
                     // We might need to box.
-                    BoundExpression leftTest = MakeTruthTestForDynamicLogicalOperator(syntax, loweredLeft, boolean, leftTruthOperator, negative: isAnd);
+                    BoundExpression leftTest = MakeTruthTestForDynamicLogicalOperator(syntax, loweredLeft, boolean, leftTruthOperator, constrainedToTypeOpt, negative: isAnd);
                     var convertedLeft = MakeConversionNode(loweredLeft, type, @checked: false);
                     result = _factory.Conditional(leftTest, convertedLeft, op, type);
                 }
@@ -667,7 +671,7 @@ private BoundExpression MakeDynamicLogicalBinaryOperator(
             return null;
         }
 
-        private BoundExpression MakeTruthTestForDynamicLogicalOperator(SyntaxNode syntax, BoundExpression loweredLeft, TypeSymbol boolean, MethodSymbol? leftTruthOperator, bool negative)
+        private BoundExpression MakeTruthTestForDynamicLogicalOperator(SyntaxNode syntax, BoundExpression loweredLeft, TypeSymbol boolean, MethodSymbol? leftTruthOperator, TypeSymbol? constrainedToTypeOpt, bool negative)
         {
             if (loweredLeft.HasDynamicType())
             {
@@ -689,7 +693,7 @@ private BoundExpression MakeTruthTestForDynamicLogicalOperator(SyntaxNode syntax
                 var converted = MakeConversionNode(loweredLeft, boolean, @checked: false);
                 if (negative)
                 {
-                    return new BoundUnaryOperator(syntax, UnaryOperatorKind.BoolLogicalNegation, converted, ConstantValue.NotAvailable, MethodSymbol.None, LookupResultKind.Viable, boolean)
+                    return new BoundUnaryOperator(syntax, UnaryOperatorKind.BoolLogicalNegation, converted, ConstantValue.NotAvailable, MethodSymbol.None, constrainedToTypeOpt: null, LookupResultKind.Viable, boolean)
                     {
                         WasCompilerGenerated = true
                     };
@@ -701,7 +705,7 @@ private BoundExpression MakeTruthTestForDynamicLogicalOperator(SyntaxNode syntax
             }
 
             Debug.Assert(leftTruthOperator != null);
-            return BoundCall.Synthesized(syntax, receiverOpt: null, leftTruthOperator, loweredLeft);
+            return BoundCall.Synthesized(syntax, receiverOpt: constrainedToTypeOpt is null ? null : new BoundTypeExpression(syntax, aliasOpt: null, constrainedToTypeOpt), leftTruthOperator, loweredLeft);
         }
 
         private BoundExpression LowerUserDefinedBinaryOperator(
@@ -710,19 +714,20 @@ private BoundExpression LowerUserDefinedBinaryOperator(
             BoundExpression loweredLeft,
             BoundExpression loweredRight,
             TypeSymbol type,
-            MethodSymbol? method)
+            MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt)
         {
             Debug.Assert(!operatorKind.IsLogical());
 
             if (operatorKind.IsLifted())
             {
-                return RewriteLiftedBinaryOperator(syntax, operatorKind, loweredLeft, loweredRight, type, method);
+                return RewriteLiftedBinaryOperator(syntax, operatorKind, loweredLeft, loweredRight, type, method, constrainedToTypeOpt);
             }
 
             // Otherwise, nothing special here.
             Debug.Assert(method is { });
             Debug.Assert(TypeSymbol.Equals(method.ReturnType, type, TypeCompareKind.ConsiderEverything2));
-            return BoundCall.Synthesized(syntax, receiverOpt: null, method, loweredLeft, loweredRight);
+            return BoundCall.Synthesized(syntax, receiverOpt: constrainedToTypeOpt is null ? null : new BoundTypeExpression(syntax, aliasOpt: null, constrainedToTypeOpt), method, loweredLeft, loweredRight);
         }
 
         private BoundExpression? TrivialLiftedComparisonOperatorOptimizations(
@@ -730,7 +735,8 @@ private BoundExpression LowerUserDefinedBinaryOperator(
             BinaryOperatorKind kind,
             BoundExpression left,
             BoundExpression right,
-            MethodSymbol? method)
+            MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt)
         {
             Debug.Assert(left != null);
             Debug.Assert(right != null);
@@ -761,7 +767,8 @@ private BoundExpression LowerUserDefinedBinaryOperator(
                     loweredLeft: leftNonNull,
                     loweredRight: rightNonNull,
                     type: boolType,
-                    method: method);
+                    method: method,
+                    constrainedToTypeOpt: constrainedToTypeOpt);
             }
 
             // Optimization #3: If one side is null and the other is definitely not, then we generate the side effects
@@ -802,7 +809,7 @@ private BoundExpression LowerUserDefinedBinaryOperator(
                 {
                     BoundExpression callHasValue = MakeNullableHasValue(syntax, maybeNull);
                     BoundExpression result = operatorKind == BinaryOperatorKind.Equal ?
-                        MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, null, callHasValue, boolType) :
+                        MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, callHasValue, boolType) :
                         callHasValue;
                     return result;
                 }
@@ -875,7 +882,7 @@ private BoundExpression LowerLiftedBuiltInComparisonOperator(
             // x <= y is not the same as (x < y) || (x == y).
 
             // Start with some simple optimizations for cases like one side being null.
-            BoundExpression? optimized = TrivialLiftedComparisonOperatorOptimizations(syntax, kind, loweredLeft, loweredRight, null);
+            BoundExpression? optimized = TrivialLiftedComparisonOperatorOptimizations(syntax, kind, loweredLeft, loweredRight, method: null, constrainedToTypeOpt: null);
             if (optimized != null)
             {
                 return optimized;
@@ -951,7 +958,8 @@ private BoundExpression LowerLiftedBuiltInComparisonOperator(
                 loweredLeft: callX_GetValueOrDefault,
                 loweredRight: callY_GetValueOrDefault,
                 type: boolType,
-                method: null);
+                method: null,
+                constrainedToTypeOpt: null);
 
             // (tempx.HasValue OP tempy.HasValue)
             BoundExpression rightExpression = MakeBinaryOperator(
@@ -960,7 +968,8 @@ private BoundExpression LowerLiftedBuiltInComparisonOperator(
                 loweredLeft: callX_HasValue,
                 loweredRight: callY_HasValue,
                 type: boolType,
-                method: null);
+                method: null,
+                constrainedToTypeOpt: null);
 
             // result = (tempx.GetValueOrDefault() OP tempy.GetValueOrDefault()) &
             //          (tempx.HasValue OP tempy.HasValue)
@@ -970,7 +979,8 @@ private BoundExpression LowerLiftedBuiltInComparisonOperator(
                 loweredLeft: leftExpression,
                 loweredRight: rightExpression,
                 type: boolType,
-                method: null);
+                method: null,
+                constrainedToTypeOpt: null);
 
             // result = !((tempx.GetValueOrDefault() == tempy.GetValueOrDefault()) &
             //            (tempx.HasValue == tempy.HasValue));
@@ -996,11 +1006,12 @@ private BoundExpression LowerLiftedUserDefinedComparisonOperator(
             BinaryOperatorKind kind,
             BoundExpression loweredLeft,
             BoundExpression loweredRight,
-            MethodSymbol? method)
+            MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt)
         {
             // If both sides are null, or neither side is null, then we can do some simple optimizations.
 
-            BoundExpression? optimized = TrivialLiftedComparisonOperatorOptimizations(syntax, kind, loweredLeft, loweredRight, method);
+            BoundExpression? optimized = TrivialLiftedComparisonOperatorOptimizations(syntax, kind, loweredLeft, loweredRight, method, constrainedToTypeOpt);
             if (optimized != null)
             {
                 return optimized;
@@ -1097,7 +1108,8 @@ private BoundExpression LowerLiftedUserDefinedComparisonOperator(
                 loweredLeft: callX_HasValue,
                 loweredRight: callY_HasValue,
                 type: boolType,
-                method: null);
+                method: null,
+                constrainedToTypeOpt: null);
 
             // tempX.GetValueOrDefault() OP tempY.GetValueOrDefault()
             BoundExpression unliftedOp = MakeBinaryOperator(
@@ -1106,7 +1118,8 @@ private BoundExpression LowerLiftedUserDefinedComparisonOperator(
                 loweredLeft: callX_GetValueOrDefault,
                 loweredRight: callY_GetValueOrDefault,
                 type: boolType,
-                method: method);
+                method: method,
+                constrainedToTypeOpt: constrainedToTypeOpt);
 
             BoundExpression consequence;
             if (operatorKind == BinaryOperatorKind.Equal || operatorKind == BinaryOperatorKind.NotEqual)
@@ -1153,7 +1166,8 @@ private BoundExpression LowerLiftedUserDefinedComparisonOperator(
             BoundExpression left,
             BoundExpression right,
             TypeSymbol type,
-            MethodSymbol? method)
+            MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt)
         {
             // We begin with a trivial optimization: if both operands are null then the 
             // result is known to be null.
@@ -1180,7 +1194,7 @@ private BoundExpression LowerLiftedUserDefinedComparisonOperator(
 
             if (leftNonNull != null && rightNonNull != null)
             {
-                return MakeLiftedBinaryOperatorConsequence(syntax, kind, leftNonNull, rightNonNull, type, method);
+                return MakeLiftedBinaryOperatorConsequence(syntax, kind, leftNonNull, rightNonNull, type, method, constrainedToTypeOpt);
             }
 
             return null;
@@ -1192,7 +1206,8 @@ private BoundExpression MakeLiftedBinaryOperatorConsequence(
             BoundExpression left,
             BoundExpression right,
             TypeSymbol type,
-            MethodSymbol? method)
+            MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt)
         {
             // tempX.GetValueOrDefault() OP tempY.GetValueOrDefault()
             BoundExpression unliftedOp = MakeBinaryOperator(
@@ -1201,7 +1216,8 @@ private BoundExpression MakeLiftedBinaryOperatorConsequence(
                 loweredLeft: left,
                 loweredRight: right,
                 type: type.GetNullableUnderlyingType(),
-                method: method);
+                method: method,
+                constrainedToTypeOpt: constrainedToTypeOpt);
 
             // new R?(tempX.GetValueOrDefault() OP tempY.GetValueOrDefault)
             return new BoundObjectCreationExpression(
@@ -1259,13 +1275,14 @@ private BoundExpression LowerLiftedBinaryArithmeticOperator(
             BoundExpression loweredLeft,
             BoundExpression loweredRight,
             TypeSymbol type,
-            MethodSymbol? method)
+            MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt)
         {
             // We have a lifted * / % + - << >> ^ & | binary operator. We begin with trivial
             // optimizations; if both sides are null or neither side is null then we can
             // eliminate the lifting altogether.
 
-            BoundExpression? optimized = OptimizeLiftedBinaryArithmetic(syntax, kind, loweredLeft, loweredRight, type, method);
+            BoundExpression? optimized = OptimizeLiftedBinaryArithmetic(syntax, kind, loweredLeft, loweredRight, type, method, constrainedToTypeOpt);
             if (optimized != null)
             {
                 return optimized;
@@ -1308,10 +1325,10 @@ private BoundExpression LowerLiftedBinaryArithmeticOperator(
 
             // tempX.HasValue & tempY.HasValue
             TypeSymbol boolType = _compilation.GetSpecialType(SpecialType.System_Boolean);
-            BoundExpression condition = MakeBinaryOperator(syntax, BinaryOperatorKind.BoolAnd, callX_HasValue, callY_HasValue, boolType, null);
+            BoundExpression condition = MakeBinaryOperator(syntax, BinaryOperatorKind.BoolAnd, callX_HasValue, callY_HasValue, boolType, method: null, constrainedToTypeOpt: null);
 
             // new R?(tempX.GetValueOrDefault() OP tempY.GetValueOrDefault)
-            BoundExpression consequence = MakeLiftedBinaryOperatorConsequence(syntax, kind, callX_GetValueOrDefault, callY_GetValueOrDefault, type, method);
+            BoundExpression consequence = MakeLiftedBinaryOperatorConsequence(syntax, kind, callX_GetValueOrDefault, callY_GetValueOrDefault, type, method, constrainedToTypeOpt);
 
             // default(R?)
             BoundExpression alternative = new BoundDefaultExpression(syntax, type);
@@ -1360,9 +1377,10 @@ private BoundExpression CaptureExpressionInTempIfNeeded(
             BoundExpression left,
             BoundExpression right,
             TypeSymbol type,
-            MethodSymbol? method)
+            MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt)
         {
-            BoundExpression? optimized = TrivialLiftedBinaryArithmeticOptimizations(syntax, kind, left, right, type, method);
+            BoundExpression? optimized = TrivialLiftedBinaryArithmeticOptimizations(syntax, kind, left, right, type, method, constrainedToTypeOpt);
             if (optimized != null)
             {
                 return optimized;
@@ -1476,8 +1494,8 @@ private BoundExpression CaptureExpressionInTempIfNeeded(
                             RewriteConditionalOperator(
                                 syntax,
                                 conditional.Condition,
-                                MakeBinaryOperator(syntax, kind, conditional.Consequence, right, type, method),
-                                MakeBinaryOperator(syntax, kind, conditional.Alternative, right, type, method),
+                                MakeBinaryOperator(syntax, kind, conditional.Consequence, right, type, method, constrainedToTypeOpt),
+                                MakeBinaryOperator(syntax, kind, conditional.Alternative, right, type, method, constrainedToTypeOpt),
                                 ConstantValue.NotAvailable,
                                 type,
                                 isRef: false),
@@ -1703,10 +1721,11 @@ private BoundExpression LowerLiftedBooleanOperator(
                 loweredLeft: callY_GetValueOrDefault,
                 loweredRight: callX_HasValue,
                 type: boolType,
-                method: null);
+                method: null,
+                constrainedToTypeOpt: null);
 
             // !(tempy.GetValueOrDefault || tempx.HasValue)
-            BoundExpression invert = MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, null, innerOr, boolType);
+            BoundExpression invert = MakeUnaryOperator(UnaryOperatorKind.BoolLogicalNegation, syntax, method: null, constrainedToTypeOpt: null, innerOr, boolType);
 
             // (x.GetValueOrDefault() || !(y.GetValueOrDefault() || x.HasValue))
             BoundExpression condition = MakeBinaryOperator(
@@ -1715,7 +1734,8 @@ private BoundExpression LowerLiftedBooleanOperator(
                 loweredLeft: callX_GetValueOrDefault,
                 loweredRight: invert,
                 type: boolType,
-                method: null);
+                method: null,
+                constrainedToTypeOpt: null);
 
             BoundExpression consequence = kind == BinaryOperatorKind.LiftedBoolAnd ? boundTempY : boundTempX;
             BoundExpression alternative = kind == BinaryOperatorKind.LiftedBoolAnd ? boundTempX : boundTempY;
@@ -1838,7 +1858,7 @@ private BoundExpression RewriteNullableNullEquality(
             BoundExpression call = MakeNullableHasValue(syntax, nullable);
             BoundExpression result = kind == BinaryOperatorKind.NullableNullNotEqual ?
                 call :
-                new BoundUnaryOperator(syntax, UnaryOperatorKind.BoolLogicalNegation, call, ConstantValue.NotAvailable, null, LookupResultKind.Viable, returnType);
+                new BoundUnaryOperator(syntax, UnaryOperatorKind.BoolLogicalNegation, call, ConstantValue.NotAvailable, null, constrainedToTypeOpt: null, LookupResultKind.Viable, returnType);
 
             return result;
         }
@@ -1847,7 +1867,7 @@ private BoundExpression RewriteStringEquality(BoundBinaryOperator? oldNode, Synt
         {
             if (oldNode != null && (loweredLeft.ConstantValue == ConstantValue.Null || loweredRight.ConstantValue == ConstantValue.Null))
             {
-                return oldNode.Update(operatorKind, oldNode.ConstantValueOpt, oldNode.MethodOpt, oldNode.ResultKind, loweredLeft, loweredRight, type);
+                return oldNode.Update(operatorKind, oldNode.ConstantValueOpt, oldNode.MethodOpt, oldNode.ConstrainedToTypeOpt, oldNode.ResultKind, loweredLeft, loweredRight, type);
             }
 
             var method = UnsafeGetSpecialTypeMethod(syntax, member);
@@ -1868,7 +1888,7 @@ private BoundExpression RewriteDelegateOperation(SyntaxNode syntax, BinaryOperat
                 {
                     // use reference equality in the absence of overloaded operators for System.Delegate.
                     operatorKind = (operatorKind & (~BinaryOperatorKind.Delegate)) | BinaryOperatorKind.Object;
-                    return new BoundBinaryOperator(syntax, operatorKind, constantValueOpt: null, null, LookupResultKind.Empty, loweredLeft, loweredRight, type);
+                    return new BoundBinaryOperator(syntax, operatorKind, constantValueOpt: null, methodOpt: null, constrainedToTypeOpt: null, LookupResultKind.Empty, loweredLeft, loweredRight, type);
                 }
             }
             else
@@ -1878,7 +1898,7 @@ private BoundExpression RewriteDelegateOperation(SyntaxNode syntax, BinaryOperat
 
             Debug.Assert((object)method != null);
             BoundExpression call = _inExpressionLambda
-                ? new BoundBinaryOperator(syntax, operatorKind, null, method, default(LookupResultKind), loweredLeft, loweredRight, method.ReturnType)
+                ? new BoundBinaryOperator(syntax, operatorKind, null, method, constrainedToTypeOpt: null, default(LookupResultKind), loweredLeft, loweredRight, method.ReturnType)
                 : (BoundExpression)BoundCall.Synthesized(syntax, receiverOpt: null, method, loweredLeft, loweredRight);
             BoundExpression result = method.ReturnType.SpecialType == SpecialType.System_Delegate ?
                 MakeConversionNode(syntax, call, Conversion.ExplicitReference, type, @checked: false) :
@@ -1966,7 +1986,8 @@ exprType is null ||
                 rewrittenExpr,
                 MakeLiteral(syntax, ConstantValue.Null, objectType),
                 boolType,
-                null);
+                method: null,
+                constrainedToTypeOpt: null);
         }
 
         /// <summary>
@@ -2005,7 +2026,8 @@ private BoundExpression RewriteBuiltInShiftOperation(
                     rightSyntax,
                     andOperatorKind,
                     null,
-                    null,
+                    methodOpt: null,
+                    constrainedToTypeOpt: null,
                     LookupResultKind.Viable,
                     loweredRight,
                     MakeLiteral(rightSyntax, ConstantValue.Create(rightMask), rightType),
@@ -2017,7 +2039,8 @@ private BoundExpression RewriteBuiltInShiftOperation(
                     syntax,
                     operatorKind,
                     null,
-                    null,
+                    methodOpt: null,
+                    constrainedToTypeOpt: null,
                     LookupResultKind.Viable,
                     loweredLeft,
                     loweredRight,
@@ -2025,7 +2048,8 @@ private BoundExpression RewriteBuiltInShiftOperation(
                 : oldNode.Update(
                     operatorKind,
                     null,
-                    null,
+                    methodOpt: null,
+                    constrainedToTypeOpt: null,
                     oldNode.ResultKind,
                     loweredLeft,
                     loweredRight,
@@ -2066,7 +2090,8 @@ private BoundExpression RewritePointerNumericOperator(
                             syntax,
                             kind,
                             ConstantValue.NotAvailable,
-                            null,
+                            methodOpt: null,
+                            constrainedToTypeOpt: null,
                             LookupResultKind.Viable,
                             loweredLeft,
                             loweredRight,
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index b6eb5a7a4e3af..57df57698e359 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -219,7 +219,8 @@ private BoundExpression MakeCall(
                     syntax,
                     BinaryOperatorKind.ObjectEqual,
                     null,
-                    null,
+                    methodOpt: null,
+                    constrainedToTypeOpt: null,
                     resultKind,
                     rewrittenArguments[0],
                     rewrittenArguments[1],
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
index 73f44b08c4385..e70fd87b6a930 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
@@ -134,7 +134,7 @@ BoundExpression rewriteAssignment(BoundExpression leftRead)
                     rewrittenType: node.Operator.LeftType,
                     @checked: isChecked);
 
-                BoundExpression operand = MakeBinaryOperator(syntax, node.Operator.Kind, opLHS, loweredRight, node.Operator.ReturnType, node.Operator.Method, isCompoundAssignment: true);
+                BoundExpression operand = MakeBinaryOperator(syntax, node.Operator.Kind, opLHS, loweredRight, node.Operator.ReturnType, node.Operator.Method, node.Operator.ConstrainedToTypeOpt, isCompoundAssignment: true);
 
                 Debug.Assert(node.Left.Type is { });
                 BoundExpression opFinal = MakeConversionNode(
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index 992a502efcf52..005192bd4326f 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -381,7 +381,9 @@ private BoundExpression MakeConversionNodeCore(
                     {
                         var mg = (BoundMethodGroup)rewrittenOperand;
                         Debug.Assert(oldNodeOpt.SymbolOpt is { });
-                        return new BoundFunctionPointerLoad(oldNodeOpt.Syntax, oldNodeOpt.SymbolOpt, type: funcPtrType, hasErrors: false);
+                        return new BoundFunctionPointerLoad(oldNodeOpt.Syntax, oldNodeOpt.SymbolOpt,
+                                                            constrainedToTypeOpt: oldNodeOpt.SymbolOpt.IsStatic && oldNodeOpt.SymbolOpt.IsAbstract ? mg.ReceiverOpt?.Type : null,
+                                                            type: funcPtrType, hasErrors: false);
                     }
 
                 case ConversionKind.MethodGroup:
@@ -393,7 +395,7 @@ private BoundExpression MakeConversionNodeCore(
                         Debug.Assert(method is { });
                         var oldSyntax = _factory.Syntax;
                         _factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax;
-                        var receiver = (!method.RequiresInstanceReceiver && !oldNodeOpt.IsExtensionMethod) ? _factory.Type(method.ContainingType) : mg.ReceiverOpt;
+                        var receiver = (!method.RequiresInstanceReceiver && !oldNodeOpt.IsExtensionMethod && !method.IsAbstract) ? _factory.Type(method.ContainingType) : mg.ReceiverOpt;
                         Debug.Assert(receiver is { });
                         _factory.Syntax = oldSyntax;
                         return new BoundDelegateCreationExpression(syntax, argument: receiver, methodOpt: method,
@@ -936,7 +938,8 @@ private BoundExpression RewriteFullyLiftedBuiltInConversion(
             if (nonNullValue != null)
             {
                 Debug.Assert(conversion.Method is { });
-                return MakeLiftedUserDefinedConversionConsequence(BoundCall.Synthesized(syntax, receiverOpt: null, conversion.Method, nonNullValue), type);
+                var constrainedToTypeOpt = conversion.ConstrainedToTypeOpt;
+                return MakeLiftedUserDefinedConversionConsequence(BoundCall.Synthesized(syntax, receiverOpt: constrainedToTypeOpt is null ? null : new BoundTypeExpression(syntax, aliasOpt: null, constrainedToTypeOpt), conversion.Method, nonNullValue), type);
             }
 
             return DistributeLiftedConversionIntoLiftedOperand(syntax, operand, conversion, false, type);
@@ -1073,7 +1076,8 @@ private BoundExpression RewriteUserDefinedConversion(
                 return new BoundReadOnlySpanFromArray(syntax, rewrittenOperand, conversion.Method, rewrittenType) { WasCompilerGenerated = true };
             }
 
-            BoundExpression result = BoundCall.Synthesized(syntax, receiverOpt: null, conversion.Method, rewrittenOperand);
+            var constrainedToTypeOpt = conversion.ConstrainedToTypeOpt;
+            BoundExpression result = BoundCall.Synthesized(syntax, receiverOpt: constrainedToTypeOpt is null ? null : new BoundTypeExpression(syntax, aliasOpt: null, constrainedToTypeOpt), conversion.Method, rewrittenOperand);
             Debug.Assert(TypeSymbol.Equals(result.Type, rewrittenType, TypeCompareKind.ConsiderEverything2));
             return result;
         }
@@ -1143,7 +1147,8 @@ private BoundExpression RewriteLiftedUserDefinedConversion(
 
             // op_Whatever(temp.GetValueOrDefault())
             Debug.Assert(conversion.Method is { });
-            BoundCall userDefinedCall = BoundCall.Synthesized(syntax, receiverOpt: null, conversion.Method, callGetValueOrDefault);
+            var constrainedToTypeOpt = conversion.ConstrainedToTypeOpt;
+            BoundCall userDefinedCall = BoundCall.Synthesized(syntax, receiverOpt: constrainedToTypeOpt is null ? null : new BoundTypeExpression(syntax, aliasOpt: null, constrainedToTypeOpt), conversion.Method, callGetValueOrDefault);
 
             // new R?(op_Whatever(temp.GetValueOrDefault())
             BoundExpression consequence = MakeLiftedUserDefinedConversionConsequence(userDefinedCall, rewrittenType);
@@ -1474,7 +1479,7 @@ private Conversion TryMakeConversion(SyntaxNode syntax, Conversion conversion, T
                         else
                         {
                             // TODO: how do we distinguish from normal and lifted conversions here?
-                            var analysis = UserDefinedConversionAnalysis.Normal(meth, fromConversion, toConversion, fromType, toType);
+                            var analysis = UserDefinedConversionAnalysis.Normal(conversion.ConstrainedToTypeOpt, meth, fromConversion, toConversion, fromType, toType);
                             var result = UserDefinedConversionResult.Valid(ImmutableArray.Create<UserDefinedConversionAnalysis>(analysis), 0);
                             return new Conversion(result, conversion.IsImplicit);
                         }
@@ -1556,6 +1561,8 @@ private Conversion TryMakeConversion(SyntaxNode syntax, TypeSymbol fromType, Typ
         /// </summary>
         private Conversion TryMakeUserDefinedConversion(SyntaxNode syntax, MethodSymbol meth, TypeSymbol fromType, TypeSymbol toType, bool isImplicit = true)
         {
+            Debug.Assert(!meth.ContainingType.IsInterface);
+
             Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type);
             if (!fromConversion.Exists)
             {
@@ -1569,7 +1576,7 @@ private Conversion TryMakeUserDefinedConversion(SyntaxNode syntax, MethodSymbol
             }
 
             // TODO: distinguish between normal and lifted conversions here
-            var analysis = UserDefinedConversionAnalysis.Normal(meth, fromConversion, toConversion, fromType, toType);
+            var analysis = UserDefinedConversionAnalysis.Normal(constrainedToTypeOpt: null, meth, fromConversion, toConversion, fromType, toType);
             var result = UserDefinedConversionResult.Valid(ImmutableArray.Create<UserDefinedConversionAnalysis>(analysis), 0);
             return new Conversion(result, isImplicit);
         }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_DelegateCreationExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_DelegateCreationExpression.cs
index 30c38120e4b9c..de93a6632a1a2 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_DelegateCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_DelegateCreationExpression.cs
@@ -30,7 +30,7 @@ public override BoundNode VisitDelegateCreationExpression(BoundDelegateCreationE
                 Debug.Assert(method is { });
                 var oldSyntax = _factory.Syntax;
                 _factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax;
-                var receiver = (!method.RequiresInstanceReceiver && !node.IsExtensionMethod) ? _factory.Type(method.ContainingType) : VisitExpression(mg.ReceiverOpt)!;
+                var receiver = (!method.RequiresInstanceReceiver && !node.IsExtensionMethod && !method.IsAbstract) ? _factory.Type(method.ContainingType) : VisitExpression(mg.ReceiverOpt)!;
                 _factory.Syntax = oldSyntax;
                 return node.Update(receiver, method, node.IsExtensionMethod, node.Type);
             }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ForEachStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ForEachStatement.cs
index c2357395e943e..408a264739d8b 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ForEachStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ForEachStatement.cs
@@ -353,6 +353,7 @@ private BoundStatement WrapWithTryFinallyDispose(
                                 type: null),
                             constantValueOpt: null,
                             methodOpt: null,
+                            constrainedToTypeOpt: null,
                             resultKind: LookupResultKind.Viable,
                             type: _compilation.GetSpecialType(SpecialType.System_Boolean)),
                         rewrittenConsequence: disposeCallStatement,
@@ -406,6 +407,7 @@ private BoundStatement WrapWithTryFinallyDispose(
                         right: MakeLiteral(forEachSyntax, constantValue: ConstantValue.Null, type: null),
                         constantValueOpt: null,
                         methodOpt: null,
+                        constrainedToTypeOpt: null,
                         resultKind: LookupResultKind.Viable,
                         type: _compilation.GetSpecialType(SpecialType.System_Boolean)),
                     rewrittenConsequence: disposeCallStatement,
@@ -604,6 +606,7 @@ private BoundStatement RewriteForEachStatementAsFor(BoundForEachStatement node,
                 right: arrayLength,
                 constantValueOpt: null,
                 methodOpt: null,
+                constrainedToTypeOpt: null,
                 resultKind: LookupResultKind.Viable,
                 type: boolType);
 
@@ -811,6 +814,7 @@ private BoundStatement RewriteSingleDimensionalArrayForEachStatement(BoundForEac
                 right: arrayLength,
                 constantValueOpt: null,
                 methodOpt: null,
+                constrainedToTypeOpt: null,
                 resultKind: LookupResultKind.Viable,
                 type: boolType);
 
@@ -991,6 +995,7 @@ private BoundStatement RewriteMultiDimensionalArrayForEachStatement(BoundForEach
                     right: boundUpperVar[dimension],
                     constantValueOpt: null,
                     methodOpt: null,
+                    constrainedToTypeOpt: null,
                     resultKind: LookupResultKind.Viable,
                     type: boolType);
 
@@ -1092,6 +1097,7 @@ private BoundStatement MakePositionIncrement(CSharpSyntaxNode syntax, BoundLocal
                                 type: intType),
                             constantValueOpt: null,
                             methodOpt: null,
+                            constrainedToTypeOpt: null,
                             resultKind: LookupResultKind.Viable,
                             type: intType),
                         type: intType)));
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
index 03afce3f2f457..1e3c780e83afe 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
@@ -192,7 +192,8 @@ ImmutableArray<BoundExpression> getAnonymousTypeValues(BoundWithExpression withE
                     Debug.Assert(left.MemberSymbol is not null);
 
                     // We evaluate the values provided in source first
-                    BoundLocal valueTemp = _factory.StoreToTemp(assignment.Right, out BoundAssignmentOperator boundAssignmentToTemp);
+                    var rewrittenRight = VisitExpression(assignment.Right);
+                    BoundLocal valueTemp = _factory.StoreToTemp(rewrittenRight, out BoundAssignmentOperator boundAssignmentToTemp);
                     temps.Add(valueTemp.LocalSymbol);
                     sideEffects.Add(boundAssignmentToTemp);
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PointerElementAccess.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PointerElementAccess.cs
index 6aa4508782925..def4723d59ba8 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PointerElementAccess.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PointerElementAccess.cs
@@ -76,6 +76,7 @@ private BoundExpression RewritePointerElementAccess(BoundPointerElementAccess no
                     rewrittenIndex,
                     rewrittenExpression.Type,
                     method: null,
+                    constrainedToTypeOpt: null,
                     isPointerElementAccess: true), //see RewriterPointerNumericOperator
                 node.Type);
         }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Range.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Range.cs
index ec8a7a51fc081..c7e1b1e8b8aab 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Range.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Range.cs
@@ -146,7 +146,7 @@ private BoundExpression LiftRangeExpression(BoundRangeExpression node, BoundExpr
                     else
                     {
                         TypeSymbol boolType = _compilation.GetSpecialType(SpecialType.System_Boolean);
-                        condition = MakeBinaryOperator(node.Syntax, BinaryOperatorKind.BoolAnd, condition, operandHasValue, boolType, method: null);
+                        condition = MakeBinaryOperator(node.Syntax, BinaryOperatorKind.BoolAnd, condition, operandHasValue, boolType, method: null, constrainedToTypeOpt: null);
                     }
 
                     return MakeOptimizedGetValueOrDefault(tempOperand.Syntax, tempOperand);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs
index 7a94845f41c0e..e2706b4979b62 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs
@@ -358,7 +358,7 @@ private BoundExpression RewriteStringConcatInExpressionLambda(SyntaxNode syntax,
             var method = UnsafeGetSpecialTypeMethod(syntax, member);
             Debug.Assert((object)method != null);
 
-            return new BoundBinaryOperator(syntax, operatorKind, constantValueOpt: null, method, default(LookupResultKind), loweredLeft, loweredRight, type);
+            return new BoundBinaryOperator(syntax, operatorKind, constantValueOpt: null, method, constrainedToTypeOpt: null, default(LookupResultKind), loweredLeft, loweredRight, type);
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TupleBinaryOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TupleBinaryOperator.cs
index ef9d49f8a4a67..7e24158b4dbc7 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TupleBinaryOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TupleBinaryOperator.cs
@@ -549,11 +549,11 @@ private BoundExpression RewriteTupleSingleOperator(TupleBinaryOperatorInfo.Singl
                 BoundExpression dynamicResult = _dynamicFactory.MakeDynamicBinaryOperator(single.Kind, left, right, isCompoundAssignment: false, _compilation.DynamicType).ToExpression();
                 if (operatorKind == BinaryOperatorKind.Equal)
                 {
-                    return _factory.Not(MakeUnaryOperator(UnaryOperatorKind.DynamicFalse, left.Syntax, method: null, dynamicResult, boolType));
+                    return _factory.Not(MakeUnaryOperator(UnaryOperatorKind.DynamicFalse, left.Syntax, method: null, constrainedToTypeOpt: null, dynamicResult, boolType));
                 }
                 else
                 {
-                    return MakeUnaryOperator(UnaryOperatorKind.DynamicTrue, left.Syntax, method: null, dynamicResult, boolType);
+                    return MakeUnaryOperator(UnaryOperatorKind.DynamicTrue, left.Syntax, method: null, constrainedToTypeOpt: null, dynamicResult, boolType);
                 }
             }
 
@@ -563,7 +563,7 @@ private BoundExpression RewriteTupleSingleOperator(TupleBinaryOperatorInfo.Singl
                 return new BoundLiteral(left.Syntax, ConstantValue.Create(operatorKind == BinaryOperatorKind.Equal), boolType);
             }
 
-            BoundExpression binary = MakeBinaryOperator(_factory.Syntax, single.Kind, left, right, single.MethodSymbolOpt?.ReturnType ?? boolType, single.MethodSymbolOpt);
+            BoundExpression binary = MakeBinaryOperator(_factory.Syntax, single.Kind, left, right, single.MethodSymbolOpt?.ReturnType ?? boolType, single.MethodSymbolOpt, single.ConstrainedToTypeOpt);
             UnaryOperatorSignature boolOperator = single.BoolOperator;
             Conversion boolConversion = single.ConversionForBool;
 
@@ -576,7 +576,7 @@ private BoundExpression RewriteTupleSingleOperator(TupleBinaryOperatorInfo.Singl
                 BoundExpression convertedBinary = MakeConversionNode(_factory.Syntax, binary, boolConversion, boolOperator.OperandType, @checked: false);
 
                 Debug.Assert(boolOperator.ReturnType.SpecialType == SpecialType.System_Boolean);
-                result = MakeUnaryOperator(boolOperator.Kind, binary.Syntax, boolOperator.Method, convertedBinary, boolType);
+                result = MakeUnaryOperator(boolOperator.Kind, binary.Syntax, boolOperator.Method, boolOperator.ConstrainedToTypeOpt, convertedBinary, boolType);
 
                 if (operatorKind == BinaryOperatorKind.Equal)
                 {
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UnaryOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UnaryOperator.cs
index b7c33842bda4b..b15d174553dac 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UnaryOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UnaryOperator.cs
@@ -55,17 +55,18 @@ public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
             }
 
             BoundExpression loweredOperand = VisitExpression(node.Operand);
-            return MakeUnaryOperator(node, node.OperatorKind, node.Syntax, node.MethodOpt, loweredOperand, node.Type);
+            return MakeUnaryOperator(node, node.OperatorKind, node.Syntax, node.MethodOpt, node.ConstrainedToTypeOpt, loweredOperand, node.Type);
         }
 
         private BoundExpression MakeUnaryOperator(
             UnaryOperatorKind kind,
             SyntaxNode syntax,
             MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt,
             BoundExpression loweredOperand,
             TypeSymbol type)
         {
-            return MakeUnaryOperator(null, kind, syntax, method, loweredOperand, type);
+            return MakeUnaryOperator(null, kind, syntax, method, constrainedToTypeOpt, loweredOperand, type);
         }
 
         private BoundExpression MakeUnaryOperator(
@@ -73,6 +74,7 @@ private BoundExpression MakeUnaryOperator(
             UnaryOperatorKind kind,
             SyntaxNode syntax,
             MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt,
             BoundExpression loweredOperand,
             TypeSymbol type)
         {
@@ -101,7 +103,7 @@ private BoundExpression MakeUnaryOperator(
             {
                 if (!_inExpressionLambda)
                 {
-                    return LowerLiftedUnaryOperator(kind, syntax, method, loweredOperand, type);
+                    return LowerLiftedUnaryOperator(kind, syntax, method, constrainedToTypeOpt, loweredOperand, type);
                 }
             }
             else if (kind.IsUserDefined())
@@ -110,7 +112,7 @@ private BoundExpression MakeUnaryOperator(
                 Debug.Assert(TypeSymbol.Equals(type, method.ReturnType, TypeCompareKind.ConsiderEverything2));
                 if (!_inExpressionLambda || kind == UnaryOperatorKind.UserDefinedTrue || kind == UnaryOperatorKind.UserDefinedFalse)
                 {
-                    return BoundCall.Synthesized(syntax, receiverOpt: null, method, loweredOperand);
+                    return BoundCall.Synthesized(syntax, receiverOpt: constrainedToTypeOpt is null ? null : new BoundTypeExpression(syntax, aliasOpt: null, constrainedToTypeOpt), method, loweredOperand);
                 }
             }
             else if (kind.Operator() == UnaryOperatorKind.UnaryPlus)
@@ -137,7 +139,8 @@ private BoundExpression MakeUnaryOperator(
                         newKind,
                         newOperand,
                         oldNode.ConstantValueOpt,
-                        method,
+                        methodOpt: method,
+                        constrainedToTypeOpt: constrainedToTypeOpt,
                         newOperand.ResultKind,
                         upconvertType) :
                     new BoundUnaryOperator(
@@ -145,7 +148,8 @@ private BoundExpression MakeUnaryOperator(
                         newKind,
                         newOperand,
                         null,
-                        method,
+                        methodOpt: method,
+                        constrainedToTypeOpt: constrainedToTypeOpt,
                         LookupResultKind.Viable,
                         upconvertType);
 
@@ -162,21 +166,22 @@ private BoundExpression MakeUnaryOperator(
             }
 
             return (oldNode != null) ?
-                oldNode.Update(kind, loweredOperand, oldNode.ConstantValueOpt, method, oldNode.ResultKind, type) :
-                new BoundUnaryOperator(syntax, kind, loweredOperand, null, method, LookupResultKind.Viable, type);
+                oldNode.Update(kind, loweredOperand, oldNode.ConstantValueOpt, methodOpt: method, constrainedToTypeOpt: constrainedToTypeOpt, oldNode.ResultKind, type) :
+                new BoundUnaryOperator(syntax, kind, loweredOperand, null, methodOpt: method, constrainedToTypeOpt: constrainedToTypeOpt, LookupResultKind.Viable, type);
         }
 
         private BoundExpression LowerLiftedUnaryOperator(
             UnaryOperatorKind kind,
             SyntaxNode syntax,
             MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt,
             BoundExpression loweredOperand,
             TypeSymbol type)
         {
             // First, an optimization. If we know that the operand is always null then
             // we can simply lower to the alternative.
 
-            BoundExpression? optimized = OptimizeLiftedUnaryOperator(kind, syntax, method, loweredOperand, type);
+            BoundExpression? optimized = OptimizeLiftedUnaryOperator(kind, syntax, method, constrainedToTypeOpt, loweredOperand, type);
             if (optimized != null)
             {
                 return optimized;
@@ -200,7 +205,7 @@ private BoundExpression LowerLiftedUnaryOperator(
             BoundExpression call_GetValueOrDefault = BoundCall.Synthesized(syntax, boundTemp, getValueOrDefault);
 
             // new R?(temp.GetValueOrDefault())
-            BoundExpression consequence = GetLiftedUnaryOperatorConsequence(kind, syntax, method, type, call_GetValueOrDefault);
+            BoundExpression consequence = GetLiftedUnaryOperatorConsequence(kind, syntax, method, constrainedToTypeOpt, type, call_GetValueOrDefault);
 
             // default(R?)
             BoundExpression alternative = new BoundDefaultExpression(syntax, type);
@@ -233,6 +238,7 @@ private BoundExpression LowerLiftedUnaryOperator(
             UnaryOperatorKind operatorKind,
             SyntaxNode syntax,
             MethodSymbol? method,
+            TypeSymbol? constrainedToTypeOpt,
             BoundExpression loweredOperand,
             TypeSymbol type)
         {
@@ -248,7 +254,7 @@ private BoundExpression LowerLiftedUnaryOperator(
             BoundExpression? neverNull = NullableAlwaysHasValue(loweredOperand);
             if (neverNull != null)
             {
-                return GetLiftedUnaryOperatorConsequence(operatorKind, syntax, method, type, neverNull);
+                return GetLiftedUnaryOperatorConsequence(operatorKind, syntax, method, constrainedToTypeOpt, type, neverNull);
             }
 
             var conditionalLeft = loweredOperand as BoundLoweredConditionalAccess;
@@ -261,7 +267,7 @@ private BoundExpression LowerLiftedUnaryOperator(
 
             if (optimize)
             {
-                var result = LowerLiftedUnaryOperator(operatorKind, syntax, method, conditionalLeft!.WhenNotNull, type);
+                var result = LowerLiftedUnaryOperator(operatorKind, syntax, method, constrainedToTypeOpt, conditionalLeft!.WhenNotNull, type);
                 Debug.Assert(result.Type is { });
 
                 return conditionalLeft.Update(
@@ -325,8 +331,8 @@ private BoundExpression LowerLiftedUnaryOperator(
                             RewriteConditionalOperator(
                                 syntax,
                                 conditional.Condition,
-                                MakeUnaryOperator(operatorKind, syntax, method, conditional.Consequence, type),
-                                MakeUnaryOperator(operatorKind, syntax, method, conditional.Alternative, type),
+                                MakeUnaryOperator(operatorKind, syntax, method, constrainedToTypeOpt, conditional.Consequence, type),
+                                MakeUnaryOperator(operatorKind, syntax, method, constrainedToTypeOpt, conditional.Alternative, type),
                                 ConstantValue.NotAvailable,
                                 type,
                                 isRef: false),
@@ -338,7 +344,7 @@ private BoundExpression LowerLiftedUnaryOperator(
             return null;
         }
 
-        private BoundExpression GetLiftedUnaryOperatorConsequence(UnaryOperatorKind kind, SyntaxNode syntax, MethodSymbol? method, TypeSymbol type, BoundExpression nonNullOperand)
+        private BoundExpression GetLiftedUnaryOperatorConsequence(UnaryOperatorKind kind, SyntaxNode syntax, MethodSymbol? method, TypeSymbol? constrainedToTypeOpt, TypeSymbol type, BoundExpression nonNullOperand)
         {
             MethodSymbol ctor = UnsafeGetNullableMethod(syntax, type, SpecialMember.System_Nullable_T__ctor);
 
@@ -348,6 +354,7 @@ private BoundExpression GetLiftedUnaryOperatorConsequence(UnaryOperatorKind kind
                 kind: kind.Unlifted(),
                 syntax: syntax,
                 method: method,
+                constrainedToTypeOpt: constrainedToTypeOpt,
                 loweredOperand: nonNullOperand,
                 type: type.GetNullableUnderlyingType());
 
@@ -614,7 +621,7 @@ private BoundExpression MakeUserDefinedIncrementOperator(BoundIncrementOperator
 
             if (!isLifted)
             {
-                return BoundCall.Synthesized(syntax, receiverOpt: null, node.MethodOpt, rewrittenArgument);
+                return BoundCall.Synthesized(syntax, receiverOpt: node.ConstrainedToTypeOpt is null ? null : new BoundTypeExpression(syntax, aliasOpt: null, node.ConstrainedToTypeOpt), node.MethodOpt, rewrittenArgument);
             }
 
             // S? temp = operand;
@@ -639,7 +646,7 @@ private BoundExpression MakeUserDefinedIncrementOperator(BoundIncrementOperator
             BoundExpression call_GetValueOrDefault = BoundCall.Synthesized(syntax, boundTemp, getValueOrDefault);
 
             // op_Increment(temp.GetValueOrDefault())
-            BoundExpression userDefinedCall = BoundCall.Synthesized(syntax, receiverOpt: null, node.MethodOpt, call_GetValueOrDefault);
+            BoundExpression userDefinedCall = BoundCall.Synthesized(syntax, receiverOpt: node.ConstrainedToTypeOpt is null ? null : new BoundTypeExpression(syntax, aliasOpt: null, node.ConstrainedToTypeOpt), node.MethodOpt, call_GetValueOrDefault);
 
             // new S?(op_Increment(temp.GetValueOrDefault()))
             BoundExpression consequence = new BoundObjectCreationExpression(syntax, ctor, userDefinedCall);
@@ -736,7 +743,7 @@ private BoundExpression MakeBuiltInIncrementOperator(BoundIncrementOperator node
                 Debug.Assert(binaryOperatorKind.OperandTypes() == BinaryOperatorKind.PointerAndInt);
                 Debug.Assert(binaryOperand.Type is { TypeKind: TypeKind.Pointer });
                 Debug.Assert(boundOne.Type is { SpecialType: SpecialType.System_Int32 });
-                return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null);
+                return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null, constrainedToTypeOpt: null);
             }
 
             // If we need to make a conversion from the unary operator type to the binary operator type,
@@ -759,7 +766,7 @@ private BoundExpression MakeBuiltInIncrementOperator(BoundIncrementOperator node
             }
             else
             {
-                binOp = MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperandType, method: null);
+                binOp = MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperandType, method: null, constrainedToTypeOpt: null);
             }
 
             // Generate the conversion back to the type of the unary operator.
diff --git a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
index 2aa13473a3b72..a28f91e5d95cc 100644
--- a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
@@ -203,6 +203,7 @@ private Conversion RewriteConversion(Conversion conversion)
             {
                 case ConversionKind.ExplicitUserDefined:
                 case ConversionKind.ImplicitUserDefined:
+                    Debug.Assert(conversion.ConstrainedToTypeOpt is null);
                     return new Conversion(conversion.Kind, VisitMethodSymbol(conversion.Method), conversion.IsExtensionMethod);
                 case ConversionKind.MethodGroup:
                     throw ExceptionUtilities.UnexpectedValue(conversion.Kind);
@@ -512,7 +513,7 @@ public override BoundNode VisitDelegateCreationExpression(BoundDelegateCreationE
 
         public override BoundNode VisitFunctionPointerLoad(BoundFunctionPointerLoad node)
         {
-            return node.Update(VisitMethodSymbol(node.TargetMethod), VisitType(node.Type));
+            return node.Update(VisitMethodSymbol(node.TargetMethod), VisitType(node.ConstrainedToTypeOpt), VisitType(node.Type));
         }
 
         public override BoundNode VisitLoweredConditionalAccess(BoundLoweredConditionalAccess node)
diff --git a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
index a8770d3e0a476..1cf16ab650741 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
@@ -826,7 +826,7 @@ public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)
                 }
             }
 
-            return UpdateExpression(builder, node.Update(node.OperatorKind, node.ConstantValue, node.MethodOpt, node.ResultKind, left, right, node.Type));
+            return UpdateExpression(builder, node.Update(node.OperatorKind, node.ConstantValue, node.MethodOpt, node.ConstrainedToTypeOpt, node.ResultKind, left, right, node.Type));
         }
 
         public override BoundNode VisitCall(BoundCall node)
@@ -835,7 +835,7 @@ public override BoundNode VisitCall(BoundCall node)
             var arguments = this.VisitExpressionList(ref builder, node.Arguments, node.ArgumentRefKindsOpt);
 
             BoundExpression receiver = null;
-            if (builder == null)
+            if (builder == null || node.ReceiverOpt is BoundTypeExpression)
             {
                 receiver = VisitExpression(ref builder, node.ReceiverOpt);
             }
@@ -1245,7 +1245,7 @@ public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
         {
             BoundSpillSequenceBuilder builder = null;
             BoundExpression operand = VisitExpression(ref builder, node.Operand);
-            return UpdateExpression(builder, node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, node.ResultKind, node.Type));
+            return UpdateExpression(builder, node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, node.ConstrainedToTypeOpt, node.ResultKind, node.Type));
         }
 
         public override BoundNode VisitReadOnlySpanFromArray(BoundReadOnlySpanFromArray node)
diff --git a/src/Compilers/CSharp/Portable/Lowering/SynthesizedMethodBaseSymbol.cs b/src/Compilers/CSharp/Portable/Lowering/SynthesizedMethodBaseSymbol.cs
index 6774c46d4f87d..7d213532146fa 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SynthesizedMethodBaseSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SynthesizedMethodBaseSymbol.cs
@@ -106,7 +106,7 @@ public sealed override ImmutableArray<ParameterSymbol> Parameters
             {
                 if (_parameters.IsDefault)
                 {
-                    ImmutableInterlocked.InterlockedCompareExchange(ref _parameters, MakeParameters(), default(ImmutableArray<ParameterSymbol>));
+                    ImmutableInterlocked.InterlockedInitialize(ref _parameters, MakeParameters());
                 }
                 return _parameters;
             }
diff --git a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
index 8f49e3445743f..f90f3fe486e9c 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
@@ -566,7 +566,7 @@ public ParameterSymbol SynthesizedParameter(TypeSymbol type, string name, Method
 
         public BoundBinaryOperator Binary(BinaryOperatorKind kind, TypeSymbol type, BoundExpression left, BoundExpression right)
         {
-            return new BoundBinaryOperator(this.Syntax, kind, ConstantValue.NotAvailable, null, LookupResultKind.Viable, left, right, type) { WasCompilerGenerated = true };
+            return new BoundBinaryOperator(this.Syntax, kind, ConstantValue.NotAvailable, methodOpt: null, constrainedToTypeOpt: null, LookupResultKind.Viable, left, right, type) { WasCompilerGenerated = true };
         }
 
         public BoundAsOperator As(BoundExpression operand, TypeSymbol type)
@@ -1410,7 +1410,7 @@ internal static BoundExpression NullOrDefault(TypeSymbol typeSymbol, SyntaxNode
         internal BoundExpression Not(BoundExpression expression)
         {
             Debug.Assert(expression is { Type: { SpecialType: CodeAnalysis.SpecialType.System_Boolean } });
-            return new BoundUnaryOperator(expression.Syntax, UnaryOperatorKind.BoolLogicalNegation, expression, null, null, LookupResultKind.Viable, expression.Type);
+            return new BoundUnaryOperator(expression.Syntax, UnaryOperatorKind.BoolLogicalNegation, expression, null, null, constrainedToTypeOpt: null, LookupResultKind.Viable, expression.Type);
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Parser/DirectiveParser.cs b/src/Compilers/CSharp/Portable/Parser/DirectiveParser.cs
index 5f507266f694c..066be0b8d5350 100644
--- a/src/Compilers/CSharp/Portable/Parser/DirectiveParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/DirectiveParser.cs
@@ -10,7 +10,6 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax
 {
-    using System.Reflection;
     using Microsoft.CodeAnalysis.Syntax.InternalSyntax;
 
     internal class DirectiveParser : SyntaxParser
@@ -87,7 +86,10 @@ public CSharpSyntaxNode ParseDirective(
                     break;
 
                 case SyntaxKind.LineKeyword:
-                    result = this.ParseLineDirective(hash, this.EatContextualToken(contextualKind), isActive);
+                    var lineKeyword = this.EatContextualToken(contextualKind);
+                    result = (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) ?
+                        this.ParseLineSpanDirective(hash, lineKeyword, isActive) :
+                        this.ParseLineDirective(hash, lineKeyword, isActive);
                     break;
 
                 case SyntaxKind.PragmaKeyword:
@@ -357,6 +359,9 @@ private DirectiveTriviaSyntax ParseErrorOrWarningDirective(SyntaxToken hash, Syn
             }
         }
 
+        private const int MaxLineValue = 0xfeefed;
+        private const int MaxCharacterValue = 0x10000;
+
         private DirectiveTriviaSyntax ParseLineDirective(SyntaxToken hash, SyntaxToken id, bool isActive)
         {
             SyntaxToken line;
@@ -377,7 +382,7 @@ private DirectiveTriviaSyntax ParseLineDirective(SyntaxToken hash, SyntaxToken i
                         {
                             line = this.AddError(line, ErrorCode.ERR_InvalidLineNumber);
                         }
-                        else if ((int)line.Value > 0xfeefed)
+                        else if ((int)line.Value > MaxLineValue)
                         {
                             line = this.AddError(line, ErrorCode.WRN_TooManyLinesForDebugger);
                         }
@@ -397,6 +402,77 @@ private DirectiveTriviaSyntax ParseLineDirective(SyntaxToken hash, SyntaxToken i
             return SyntaxFactory.LineDirectiveTrivia(hash, id, line, file, end, isActive);
         }
 
+        private LineSpanDirectiveTriviaSyntax ParseLineSpanDirective(SyntaxToken hash, SyntaxToken lineKeyword, bool isActive)
+        {
+            Debug.Assert(CurrentToken.Kind == SyntaxKind.OpenParenToken);
+
+            if (isActive)
+            {
+                lineKeyword = CheckFeatureAvailability(lineKeyword, MessageID.IDS_FeatureLineSpanDirective);
+            }
+
+            bool reportError = isActive;
+            var start = ParseLineDirectivePosition(ref reportError, out int startLine, out int startCharacter);
+
+            var minus = EatToken(SyntaxKind.MinusToken, reportError: reportError);
+            if (minus.IsMissing) reportError = false;
+
+            var end = ParseLineDirectivePosition(ref reportError, out int endLine, out int endCharacter);
+            if (reportError &&
+                (endLine < startLine || (endLine == startLine && endCharacter < startCharacter)))
+            {
+                end = this.AddError(end, ErrorCode.ERR_LineSpanDirectiveEndLessThanStart);
+            }
+
+            var characterOffset = (CurrentToken.Kind == SyntaxKind.NumericLiteralToken) ?
+                ParseLineDirectiveNumericLiteral(ref reportError, minValue: 1, maxValue: MaxCharacterValue, out _) :
+                null;
+
+            var file = EatToken(SyntaxKind.StringLiteralToken, ErrorCode.ERR_MissingPPFile, reportError: reportError);
+            if (file.IsMissing) reportError = false;
+
+            var endOfDirective = this.ParseEndOfDirective(ignoreErrors: !reportError);
+            return SyntaxFactory.LineSpanDirectiveTrivia(hash, lineKeyword, start, minus, end, characterOffset, file, endOfDirective, isActive);
+        }
+
+        private LineDirectivePositionSyntax ParseLineDirectivePosition(ref bool reportError, out int line, out int character)
+        {
+            var openParen = EatToken(SyntaxKind.OpenParenToken, reportError);
+            if (openParen.IsMissing) reportError = false;
+
+            var lineToken = ParseLineDirectiveNumericLiteral(ref reportError, minValue: 1, maxValue: MaxLineValue, out line);
+
+            var comma = EatToken(SyntaxKind.CommaToken, reportError);
+            if (comma.IsMissing) reportError = false;
+
+            var characterToken = ParseLineDirectiveNumericLiteral(ref reportError, minValue: 1, maxValue: MaxCharacterValue, out character);
+
+            var closeParen = EatToken(SyntaxKind.CloseParenToken, reportError);
+            if (closeParen.IsMissing) reportError = false;
+
+            return SyntaxFactory.LineDirectivePosition(openParen, lineToken, comma, characterToken, closeParen);
+        }
+
+        private SyntaxToken ParseLineDirectiveNumericLiteral(ref bool reportError, int minValue, int maxValue, out int value)
+        {
+            var token = this.EatToken(SyntaxKind.NumericLiteralToken, ErrorCode.ERR_LineSpanDirectiveInvalidValue, reportError: reportError);
+            value = 0;
+            if (token.IsMissing)
+            {
+                reportError = false;
+            }
+            else if (token.Kind == SyntaxKind.NumericLiteralToken)
+            {
+                value = (int)token.Value;
+                if (value < minValue || value > maxValue)
+                {
+                    token = this.AddError(token, ErrorCode.ERR_LineSpanDirectiveInvalidValue);
+                    reportError = false;
+                }
+            }
+            return token;
+        }
+
         private DirectiveTriviaSyntax ParseReferenceDirective(SyntaxToken hash, SyntaxToken keyword, bool isActive, bool isFollowingToken)
         {
             if (isActive)
diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 88bc472607d29..37f5aa90cb7e1 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -7,7 +7,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.Contracts;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.Text;
@@ -2344,11 +2343,10 @@ private MemberDeclarationSyntax ParseMemberDeclarationOrStatementCore(SyntaxKind
                 }
 
                 // Check for conversion operators (implicit/explicit)
-                if (this.CurrentToken.Kind == SyntaxKind.ExplicitKeyword ||
-                    this.CurrentToken.Kind == SyntaxKind.ImplicitKeyword ||
-                        (this.CurrentToken.Kind == SyntaxKind.OperatorKeyword && !SyntaxFacts.IsAnyOverloadableOperator(this.PeekToken(1).Kind)))
+                result = this.TryParseConversionOperatorDeclaration(attributes, modifiers);
+                if (result is not null)
                 {
-                    return this.ParseConversionOperatorDeclaration(attributes, modifiers);
+                    return result;
                 }
 
                 if (this.CurrentToken.Kind == SyntaxKind.NamespaceKeyword)
@@ -2368,7 +2366,8 @@ private MemberDeclarationSyntax ParseMemberDeclarationOrStatementCore(SyntaxKind
 
                 try
                 {
-                    if ((!haveAttributes || !IsScript) && !haveModifiers && (type.Kind == SyntaxKind.RefType || !IsOperatorKeyword()))
+                    // Try as a regular statement rather than a member declaration, if appropriate.
+                    if ((!haveAttributes || !IsScript) && !haveModifiers && (type.Kind == SyntaxKind.RefType || !IsOperatorStart(out _, advanceParser: false)))
                     {
                         this.Reset(ref afterAttributesPoint);
 
@@ -2414,12 +2413,13 @@ private MemberDeclarationSyntax ParseMemberDeclarationOrStatementCore(SyntaxKind
 parse_member_name:;
                     // If we've seen the ref keyword, we know we must have an indexer, method, property, or local.
                     bool typeIsRef = type.IsRef;
+                    ExplicitInterfaceSpecifierSyntax explicitInterfaceOpt;
 
                     // Check here for operators
                     // Allow old-style implicit/explicit casting operator syntax, just so we can give a better error
-                    if (!typeIsRef && IsOperatorKeyword())
+                    if (!typeIsRef && IsOperatorStart(out explicitInterfaceOpt))
                     {
-                        return this.ParseOperatorDeclaration(attributes, modifiers, type);
+                        return this.ParseOperatorDeclaration(attributes, modifiers, type, explicitInterfaceOpt);
                     }
 
                     if ((!typeIsRef || !IsScript) && IsFieldDeclaration(isEvent: false))
@@ -2456,7 +2456,6 @@ private MemberDeclarationSyntax ParseMemberDeclarationOrStatementCore(SyntaxKind
                     // At this point we can either have indexers, methods, or 
                     // properties (or something unknown).  Try to break apart
                     // the following name and determine what to do from there.
-                    ExplicitInterfaceSpecifierSyntax explicitInterfaceOpt;
                     SyntaxToken identifierOrThisOpt;
                     TypeParameterListSyntax typeParameterListOpt;
                     this.ParseMemberName(out explicitInterfaceOpt, out identifierOrThisOpt, out typeParameterListOpt, isEvent: false);
@@ -2764,11 +2763,10 @@ private MemberDeclarationSyntax ParseMemberDeclarationCore(SyntaxKind parentKind
                 }
 
                 // Check for conversion operators (implicit/explicit)
-                if (this.CurrentToken.Kind == SyntaxKind.ExplicitKeyword ||
-                    this.CurrentToken.Kind == SyntaxKind.ImplicitKeyword ||
-                        (this.CurrentToken.Kind == SyntaxKind.OperatorKeyword && !SyntaxFacts.IsAnyOverloadableOperator(this.PeekToken(1).Kind)))
+                MemberDeclarationSyntax result = this.TryParseConversionOperatorDeclaration(attributes, modifiers);
+                if (result is not null)
                 {
-                    return this.ParseConversionOperatorDeclaration(attributes, modifiers);
+                    return result;
                 }
 
                 // Namespaces should be handled by the caller, not checking for them
@@ -2790,21 +2788,22 @@ private MemberDeclarationSyntax ParseMemberDeclarationCore(SyntaxKind parentKind
                 {
                     // Check for misplaced modifiers.  if we see any, then consider this member
                     // terminated and restart parsing.
-                    MemberDeclarationSyntax result;
                     if (IsMisplacedModifier(modifiers, attributes, type, out result))
                     {
                         return result;
                     }
 
 parse_member_name:;
+                    ExplicitInterfaceSpecifierSyntax explicitInterfaceOpt;
+
                     // If we've seen the ref keyword, we know we must have an indexer, method, or property.
                     if (type.Kind != SyntaxKind.RefType)
                     {
                         // Check here for operators
                         // Allow old-style implicit/explicit casting operator syntax, just so we can give a better error
-                        if (IsOperatorKeyword())
+                        if (IsOperatorStart(out explicitInterfaceOpt))
                         {
-                            return this.ParseOperatorDeclaration(attributes, modifiers, type);
+                            return this.ParseOperatorDeclaration(attributes, modifiers, type, explicitInterfaceOpt);
                         }
 
                         if (IsFieldDeclaration(isEvent: false))
@@ -2816,7 +2815,6 @@ private MemberDeclarationSyntax ParseMemberDeclarationCore(SyntaxKind parentKind
                     // At this point we can either have indexers, methods, or 
                     // properties (or something unknown).  Try to break apart
                     // the following name and determine what to do from there.
-                    ExplicitInterfaceSpecifierSyntax explicitInterfaceOpt;
                     SyntaxToken identifierOrThisOpt;
                     TypeParameterListSyntax typeParameterListOpt;
                     this.ParseMemberName(out explicitInterfaceOpt, out identifierOrThisOpt, out typeParameterListOpt, isEvent: false);
@@ -2912,6 +2910,7 @@ private bool IsFieldDeclaration(bool isEvent)
             {
                 case SyntaxKind.DotToken:                   // Goo.     explicit
                 case SyntaxKind.ColonColonToken:            // Goo::    explicit
+                case SyntaxKind.DotDotToken:                // Goo..    explicit
                 case SyntaxKind.LessThanToken:            // Goo<     explicit or generic method
                 case SyntaxKind.OpenBraceToken:        // Goo {    property
                 case SyntaxKind.EqualsGreaterThanToken:     // Goo =>   property
@@ -3241,45 +3240,185 @@ private bool IsEndOfReturnType()
             }
         }
 
-        private ConversionOperatorDeclarationSyntax ParseConversionOperatorDeclaration(SyntaxList<AttributeListSyntax> attributes, SyntaxListBuilder modifiers)
+        private ConversionOperatorDeclarationSyntax TryParseConversionOperatorDeclaration(SyntaxList<AttributeListSyntax> attributes, SyntaxListBuilder modifiers)
         {
-            SyntaxToken style;
-            if (this.CurrentToken.Kind == SyntaxKind.ImplicitKeyword || this.CurrentToken.Kind == SyntaxKind.ExplicitKeyword)
+            var point = GetResetPoint();
+
+            try
             {
-                style = this.EatToken();
+                SyntaxToken style;
+                if (this.CurrentToken.Kind == SyntaxKind.ImplicitKeyword || this.CurrentToken.Kind == SyntaxKind.ExplicitKeyword)
+                {
+                    style = this.EatToken();
+                }
+                else
+                {
+                    style = this.EatToken(SyntaxKind.ExplicitKeyword);
+                }
+
+                ExplicitInterfaceSpecifierSyntax explicitInterfaceOpt = tryParseExplicitInterfaceSpecifier();
+                SyntaxToken opKeyword;
+                TypeSyntax type;
+                ParameterListSyntax paramList;
+
+                if (style.IsMissing)
+                {
+                    if (this.CurrentToken.Kind != SyntaxKind.OperatorKeyword || SyntaxFacts.IsAnyOverloadableOperator(this.PeekToken(1).Kind) ||
+                        explicitInterfaceOpt?.DotToken.IsMissing == true)
+                    {
+                        this.Reset(ref point);
+                        return null;
+                    }
+                }
+                else if (explicitInterfaceOpt is not null && this.CurrentToken.Kind != SyntaxKind.OperatorKeyword && style.TrailingTrivia.Any((int)SyntaxKind.EndOfLineTrivia))
+                {
+                    // Not likely an explicit interface implementation. Likely a begining of the next member on the next line.
+                    this.Reset(ref point);
+                    style = this.EatToken();
+                    explicitInterfaceOpt = null;
+                    opKeyword = this.EatToken(SyntaxKind.OperatorKeyword);
+                    type = this.AddError(this.CreateMissingIdentifierName(), ErrorCode.ERR_IdentifierExpected);
+                    SyntaxToken open = SyntaxFactory.MissingToken(SyntaxKind.OpenParenToken);
+                    SyntaxToken close = SyntaxFactory.MissingToken(SyntaxKind.CloseParenToken);
+                    var parameters = _pool.AllocateSeparated<ParameterSyntax>();
+                    paramList = _syntaxFactory.ParameterList(open, parameters, close);
+                    _pool.Free(parameters);
+
+                    return _syntaxFactory.ConversionOperatorDeclaration(
+                        attributes,
+                        modifiers.ToList(),
+                        style,
+                        explicitInterfaceOpt,
+                        opKeyword,
+                        type,
+                        paramList,
+                        body: null,
+                        expressionBody: null,
+                        semicolonToken: SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken));
+                }
+
+                opKeyword = this.EatToken(SyntaxKind.OperatorKeyword);
+
+                this.Release(ref point);
+                point = GetResetPoint();
+
+                bool couldBeParameterList = this.CurrentToken.Kind == SyntaxKind.OpenParenToken;
+                type = this.ParseType();
+
+                if (couldBeParameterList && type is TupleTypeSyntax { Elements: { Count: 2, SeparatorCount: 1 } } tupleType &&
+                    tupleType.Elements.GetSeparator(0).IsMissing && tupleType.Elements[1].IsMissing &&
+                    this.CurrentToken.Kind != SyntaxKind.OpenParenToken)
+                {
+                    // It looks like the type is missing and we parsed parameter list as the type. Recover.
+                    this.Reset(ref point);
+                    type = ParseIdentifierName();
+                }
+
+                paramList = this.ParseParenthesizedParameterList();
+
+                BlockSyntax blockBody;
+                ArrowExpressionClauseSyntax expressionBody;
+                SyntaxToken semicolon;
+                this.ParseBlockAndExpressionBodiesWithSemicolon(out blockBody, out expressionBody, out semicolon);
+
+                return _syntaxFactory.ConversionOperatorDeclaration(
+                    attributes,
+                    modifiers.ToList(),
+                    style,
+                    explicitInterfaceOpt,
+                    opKeyword,
+                    type,
+                    paramList,
+                    blockBody,
+                    expressionBody,
+                    semicolon);
             }
-            else
+            finally
             {
-                style = this.EatToken(SyntaxKind.ExplicitKeyword);
+                this.Release(ref point);
             }
 
-            SyntaxToken opKeyword = this.EatToken(SyntaxKind.OperatorKeyword);
+            ExplicitInterfaceSpecifierSyntax tryParseExplicitInterfaceSpecifier()
+            {
+                if (this.CurrentToken.Kind == SyntaxKind.OperatorKeyword)
+                {
+                    return null;
+                }
 
-            var type = this.ParseType();
+                if (this.CurrentToken.Kind != SyntaxKind.IdentifierToken)
+                {
+                    return null;
+                }
 
-            var paramList = this.ParseParenthesizedParameterList();
+                NameSyntax explicitInterfaceName = null;
+                SyntaxToken separator = null;
 
-            BlockSyntax blockBody;
-            ArrowExpressionClauseSyntax expressionBody;
-            SyntaxToken semicolon;
-            this.ParseBlockAndExpressionBodiesWithSemicolon(out blockBody, out expressionBody, out semicolon);
+                while (true)
+                {
+                    // now, scan past the next name.  if it's followed by a dot then
+                    // it's part of the explicit name we're building up.  Otherwise,
+                    // it should be an operator token
+                    var point = GetResetPoint();
+                    bool isPartOfInterfaceName;
+                    try
+                    {
+                        if (this.CurrentToken.Kind == SyntaxKind.OperatorKeyword)
+                        {
+                            isPartOfInterfaceName = false;
+                        }
+                        else
+                        {
+                            int lastTokenPosition = -1;
+                            IsMakingProgress(ref lastTokenPosition, assertIfFalse: true);
+                            ScanNamedTypePart();
+                            isPartOfInterfaceName = IsDotOrColonColonOrDotDot() ||
+                                                    (IsMakingProgress(ref lastTokenPosition, assertIfFalse: false) && this.CurrentToken.Kind != SyntaxKind.OpenParenToken);
+                        }
+                    }
+                    finally
+                    {
+                        this.Reset(ref point);
+                        this.Release(ref point);
+                    }
 
-            return _syntaxFactory.ConversionOperatorDeclaration(
-                attributes,
-                modifiers.ToList(),
-                style,
-                opKeyword,
-                type,
-                paramList,
-                blockBody,
-                expressionBody,
-                semicolon);
+                    if (!isPartOfInterfaceName)
+                    {
+                        // We're past any explicit interface portion
+                        if (separator != null && separator.Kind == SyntaxKind.ColonColonToken)
+                        {
+                            separator = this.AddError(separator, ErrorCode.ERR_AliasQualAsExpression);
+                            separator = this.ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken);
+                        }
+
+                        break;
+                    }
+                    else
+                    {
+                        // If we saw a . or :: then we must have something explicit.
+                        AccumulateExplicitInterfaceName(ref explicitInterfaceName, ref separator, reportAnErrorOnMisplacedColonColon: true);
+                    }
+                }
+
+                if (explicitInterfaceName is null)
+                {
+                    return null;
+                }
+
+                if (separator.Kind != SyntaxKind.DotToken)
+                {
+                    separator = WithAdditionalDiagnostics(separator, GetExpectedTokenError(SyntaxKind.DotToken, separator.Kind, separator.GetLeadingTriviaWidth(), separator.Width));
+                    separator = ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken);
+                }
+
+                return CheckFeatureAvailability(_syntaxFactory.ExplicitInterfaceSpecifier(explicitInterfaceName, separator), MessageID.IDS_FeatureStaticAbstractMembersInInterfaces);
+            }
         }
 
         private OperatorDeclarationSyntax ParseOperatorDeclaration(
             SyntaxList<AttributeListSyntax> attributes,
             SyntaxListBuilder modifiers,
-            TypeSyntax type)
+            TypeSyntax type,
+            ExplicitInterfaceSpecifierSyntax explicitInterfaceOpt)
         {
             var opKeyword = this.EatToken(SyntaxKind.OperatorKeyword);
             SyntaxToken opToken;
@@ -3399,6 +3538,7 @@ private OperatorDeclarationSyntax ParseOperatorDeclaration(
                 attributes,
                 modifiers.ToList(),
                 type,
+                explicitInterfaceOpt,
                 opKeyword,
                 opToken,
                 paramList,
@@ -4125,8 +4265,7 @@ private void ParseParameterList(
 
         private bool IsEndOfParameterList()
         {
-            return this.CurrentToken.Kind == SyntaxKind.CloseParenToken
-                || this.CurrentToken.Kind == SyntaxKind.CloseBracketToken;
+            return this.CurrentToken.Kind is SyntaxKind.CloseParenToken or SyntaxKind.CloseBracketToken or SyntaxKind.SemicolonToken;
         }
 
         private PostSkipAction SkipBadParameterListTokens(
@@ -5994,7 +6133,7 @@ private void ParseMemberName(
                     try
                     {
                         ScanNamedTypePart();
-                        isMemberName = !IsDotOrColonColon();
+                        isMemberName = !IsDotOrColonColonOrDotDot();
                     }
                     finally
                     {
@@ -6022,37 +6161,7 @@ private void ParseMemberName(
                     else
                     {
                         // If we saw a . or :: then we must have something explicit.
-                        // first parse the upcoming name portion.
-
-                        var saveTerm = _termState;
-                        _termState |= TerminatorState.IsEndOfNameInExplicitInterface;
-
-                        if (explicitInterfaceName == null)
-                        {
-                            // If this is the first time, then just get the next simple
-                            // name and store it as the explicit interface name.
-                            explicitInterfaceName = this.ParseSimpleName(NameOptions.InTypeList);
-
-                            // Now, get the next separator.
-                            separator = this.CurrentToken.Kind == SyntaxKind.ColonColonToken
-                                ? this.EatToken() // fine after the first identifier
-                                : this.EatToken(SyntaxKind.DotToken);
-                        }
-                        else
-                        {
-                            // Parse out the next part and combine it with the 
-                            // current explicit name to form the new explicit name.
-                            var tmp = this.ParseQualifiedNameRight(NameOptions.InTypeList, explicitInterfaceName, separator);
-                            Debug.Assert(!ReferenceEquals(tmp, explicitInterfaceName), "We should have consumed something and updated explicitInterfaceName");
-                            explicitInterfaceName = tmp;
-
-                            // Now, get the next separator.
-                            separator = this.CurrentToken.Kind == SyntaxKind.ColonColonToken
-                                ? this.ConvertToMissingWithTrailingTrivia(this.EatToken(), SyntaxKind.DotToken)
-                                : this.EatToken(SyntaxKind.DotToken);
-                        }
-
-                        _termState = saveTerm;
+                        AccumulateExplicitInterfaceName(ref explicitInterfaceName, ref separator);
                     }
                 }
 
@@ -6121,6 +6230,170 @@ private void ParseMemberName(
             }
         }
 
+        private void AccumulateExplicitInterfaceName(ref NameSyntax explicitInterfaceName, ref SyntaxToken separator, bool reportAnErrorOnMisplacedColonColon = false)
+        {
+            // first parse the upcoming name portion.
+
+            var saveTerm = _termState;
+            _termState |= TerminatorState.IsEndOfNameInExplicitInterface;
+
+            if (explicitInterfaceName == null)
+            {
+                // If this is the first time, then just get the next simple
+                // name and store it as the explicit interface name.
+                explicitInterfaceName = this.ParseSimpleName(NameOptions.InTypeList);
+
+                // Now, get the next separator.
+                if (this.CurrentToken.Kind == SyntaxKind.DotDotToken)
+                {
+                    // Error recovery as in ParseQualifiedNameRight. If we have `X..Y` break that into `X.<missing-id>.Y`
+                    separator = this.EatToken();
+                    explicitInterfaceName = RecoverFromDotDot(explicitInterfaceName, ref separator);
+                }
+                else
+                {
+                    separator = this.CurrentToken.Kind == SyntaxKind.ColonColonToken
+                        ? this.EatToken() // fine after the first identifier
+                        : this.EatToken(SyntaxKind.DotToken);
+                }
+            }
+            else
+            {
+                // Parse out the next part and combine it with the 
+                // current explicit name to form the new explicit name.
+                var tmp = this.ParseQualifiedNameRight(NameOptions.InTypeList, explicitInterfaceName, separator);
+                Debug.Assert(!ReferenceEquals(tmp, explicitInterfaceName), "We should have consumed something and updated explicitInterfaceName");
+                explicitInterfaceName = tmp;
+
+                // Now, get the next separator.
+                if (this.CurrentToken.Kind == SyntaxKind.ColonColonToken)
+                {
+                    separator = this.EatToken();
+
+                    if (reportAnErrorOnMisplacedColonColon)
+                    {
+                        // The https://github.com/dotnet/roslyn/issues/53021 is tracking fixing this in general
+                        separator = this.AddError(separator, ErrorCode.ERR_UnexpectedAliasedName);
+                    }
+
+                    separator = this.ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken);
+                }
+                else if (this.CurrentToken.Kind == SyntaxKind.DotDotToken)
+                {
+                    // Error recovery as in ParseQualifiedNameRight. If we have `X..Y` break that into `X.<missing-id>.Y`
+                    separator = this.EatToken();
+                    explicitInterfaceName = RecoverFromDotDot(explicitInterfaceName, ref separator);
+                }
+                else
+                {
+                    separator = this.EatToken(SyntaxKind.DotToken);
+                }
+            }
+
+            _termState = saveTerm;
+        }
+
+        /// <summary>
+        /// This is an adjusted version of <see cref="ParseMemberName"/>.
+        /// When it returns true, it stops at operator keyword (<see cref="IsOperatorKeyword"/>).
+        /// When it returns false, it does not advance in the token stream.
+        /// </summary>
+        private bool IsOperatorStart(out ExplicitInterfaceSpecifierSyntax explicitInterfaceOpt, bool advanceParser = true)
+        {
+            explicitInterfaceOpt = null;
+
+            if (IsOperatorKeyword())
+            {
+                return true;
+            }
+
+            if (this.CurrentToken.Kind != SyntaxKind.IdentifierToken)
+            {
+                return false;
+            }
+
+            NameSyntax explicitInterfaceName = null;
+            SyntaxToken separator = null;
+
+            ResetPoint beforeIdentifierPoint = GetResetPoint();
+
+            try
+            {
+                while (true)
+                {
+                    // now, scan past the next name.  if it's followed by a dot then
+                    // it's part of the explicit name we're building up.  Otherwise,
+                    // it should be an operator token
+                    var point = GetResetPoint();
+                    bool isPartOfInterfaceName;
+                    try
+                    {
+                        if (IsOperatorKeyword())
+                        {
+                            isPartOfInterfaceName = false;
+                        }
+                        else
+                        {
+                            ScanNamedTypePart();
+
+                            // If we have part of the interface name, but no dot before the operator token, then
+                            // for the purpose of error recovery, treat this as an operator start with a
+                            // missing dot token.
+                            isPartOfInterfaceName = IsDotOrColonColonOrDotDot() || IsOperatorKeyword();
+                        }
+                    }
+                    finally
+                    {
+                        this.Reset(ref point);
+                        this.Release(ref point);
+                    }
+
+                    if (!isPartOfInterfaceName)
+                    {
+                        // We're past any explicit interface portion
+                        if (separator != null && separator.Kind == SyntaxKind.ColonColonToken)
+                        {
+                            separator = this.AddError(separator, ErrorCode.ERR_AliasQualAsExpression);
+                            separator = this.ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken);
+                        }
+
+                        break;
+                    }
+                    else
+                    {
+                        // If we saw a . or :: then we must have something explicit.
+                        AccumulateExplicitInterfaceName(ref explicitInterfaceName, ref separator, reportAnErrorOnMisplacedColonColon: true);
+                    }
+                }
+
+                if (!IsOperatorKeyword() || explicitInterfaceName is null)
+                {
+                    Reset(ref beforeIdentifierPoint);
+                    return false;
+                }
+
+                if (!advanceParser)
+                {
+                    Reset(ref beforeIdentifierPoint);
+                    return true;
+                }
+
+                if (separator.Kind != SyntaxKind.DotToken)
+                {
+                    separator = WithAdditionalDiagnostics(separator, GetExpectedTokenError(SyntaxKind.DotToken, separator.Kind, separator.GetLeadingTriviaWidth(), separator.Width));
+                    separator = ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken);
+                }
+
+                explicitInterfaceOpt = CheckFeatureAvailability(_syntaxFactory.ExplicitInterfaceSpecifier(explicitInterfaceName, separator), MessageID.IDS_FeatureStaticAbstractMembersInInterfaces);
+
+                return true;
+            }
+            finally
+            {
+                Release(ref beforeIdentifierPoint);
+            }
+        }
+
         private NameSyntax ParseAliasQualifiedName(NameOptions allowedParts = NameOptions.None)
         {
             NameSyntax name = this.ParseSimpleName(allowedParts);
@@ -6138,7 +6411,7 @@ private NameSyntax ParseQualifiedName(NameOptions options = NameOptions.None)
             NameSyntax name = this.ParseAliasQualifiedName(options);
 
             // Handle .. tokens for error recovery purposes.
-            while (this.IsDotOrColonColon() || this.CurrentToken.Kind == SyntaxKind.DotDotToken)
+            while (IsDotOrColonColonOrDotDot())
             {
                 if (this.PeekToken(1).Kind == SyntaxKind.ThisKeyword)
                 {
@@ -6152,6 +6425,11 @@ private NameSyntax ParseQualifiedName(NameOptions options = NameOptions.None)
             return name;
         }
 
+        private bool IsDotOrColonColonOrDotDot()
+        {
+            return this.IsDotOrColonColon() || this.CurrentToken.Kind == SyntaxKind.DotDotToken;
+        }
+
         private NameSyntax ParseQualifiedNameRight(
             NameOptions options,
             NameSyntax left,
@@ -6169,14 +6447,7 @@ private NameSyntax ParseQualifiedNameRight(
                     return _syntaxFactory.QualifiedName(left, separator, right);
                 case SyntaxKind.DotDotToken:
                     // Error recovery.  If we have `X..Y` break that into `X.<missing-id>.Y`
-
-                    var leftDot = SyntaxFactory.Token(separator.LeadingTrivia.Node, SyntaxKind.DotToken, null);
-                    var missingName = this.AddError(this.CreateMissingIdentifierName(), ErrorCode.ERR_IdentifierExpected);
-                    var rightDot = SyntaxFactory.Token(null, SyntaxKind.DotToken, separator.TrailingTrivia.Node);
-
-                    return _syntaxFactory.QualifiedName(
-                        _syntaxFactory.QualifiedName(left, leftDot, missingName),
-                        rightDot, right);
+                    return _syntaxFactory.QualifiedName(RecoverFromDotDot(left, ref separator), separator, right);
 
                 case SyntaxKind.ColonColonToken:
                     if (left.Kind != SyntaxKind.IdentifierName)
@@ -6213,6 +6484,16 @@ private NameSyntax ParseQualifiedNameRight(
             }
         }
 
+        private NameSyntax RecoverFromDotDot(NameSyntax left, ref SyntaxToken separator)
+        {
+            Debug.Assert(separator.Kind == SyntaxKind.DotDotToken);
+
+            var leftDot = SyntaxFactory.Token(separator.LeadingTrivia.Node, SyntaxKind.DotToken, null);
+            var missingName = this.AddError(this.CreateMissingIdentifierName(), ErrorCode.ERR_IdentifierExpected);
+            separator = SyntaxFactory.Token(null, SyntaxKind.DotToken, separator.TrailingTrivia.Node);
+            return _syntaxFactory.QualifiedName(left, leftDot, missingName);
+        }
+
         private SyntaxToken ConvertToMissingWithTrailingTrivia(SyntaxToken token, SyntaxKind expectedKind)
         {
             var newToken = SyntaxFactory.MissingToken(expectedKind);
@@ -6317,6 +6598,7 @@ private ScanTypeFlags ScanType(ParseTypeMode mode, out SyntaxToken lastTokenOfTy
         {
             Debug.Assert(mode != ParseTypeMode.NewExpression);
             ScanTypeFlags result;
+            bool isFunctionPointer = false;
 
             if (this.CurrentToken.Kind == SyntaxKind.RefKeyword)
             {
@@ -6406,6 +6688,7 @@ private ScanTypeFlags ScanType(ParseTypeMode mode, out SyntaxToken lastTokenOfTy
             }
             else if (IsFunctionPointerStart())
             {
+                isFunctionPointer = true;
                 result = ScanFunctionPointerType(out lastTokenOfType);
             }
             else
@@ -6422,7 +6705,8 @@ private ScanTypeFlags ScanType(ParseTypeMode mode, out SyntaxToken lastTokenOfTy
                 {
                     case SyntaxKind.QuestionToken
                             when lastTokenOfType.Kind != SyntaxKind.QuestionToken && // don't allow `Type??`
-                                 lastTokenOfType.Kind != SyntaxKind.AsteriskToken: // don't allow `Type*?`
+                                 lastTokenOfType.Kind != SyntaxKind.AsteriskToken && // don't allow `Type*?`
+                                 !isFunctionPointer: // don't allow `delegate*<...>?`
                         lastTokenOfType = this.EatToken();
                         result = ScanTypeFlags.NullableType;
                         break;
@@ -6446,6 +6730,7 @@ private ScanTypeFlags ScanType(ParseTypeMode mode, out SyntaxToken lastTokenOfTy
                                 goto done;
                             default:
                                 lastTokenOfType = this.EatToken();
+                                isFunctionPointer = false;
                                 if (result == ScanTypeFlags.GenericTypeOrExpression || result == ScanTypeFlags.NonGenericTypeOrExpression)
                                 {
                                     result = ScanTypeFlags.PointerOrMultiplication;
@@ -6472,6 +6757,7 @@ private ScanTypeFlags ScanType(ParseTypeMode mode, out SyntaxToken lastTokenOfTy
                         }
 
                         lastTokenOfType = this.EatToken();
+                        isFunctionPointer = false;
                         result = ScanTypeFlags.MustBeType;
                         break;
                     default:
@@ -9768,7 +10054,7 @@ private bool IsPossibleExpression(bool allowBinaryExpressions, bool allowAssignm
                     // expression (whether it is used as an identifier or a keyword).
                     return this.IsTrueIdentifier() || (this.CurrentToken.ContextualKind == SyntaxKind.FromKeyword);
                 default:
-                    return (IsPredefinedType(tk) && tk != SyntaxKind.VoidKeyword)
+                    return IsPredefinedType(tk)
                         || SyntaxFacts.IsAnyUnaryExpression(tk)
                         || (allowBinaryExpressions && SyntaxFacts.IsBinaryExpression(tk))
                         || (allowAssignmentExpressions && SyntaxFacts.IsAssignmentExpressionOperatorToken(tk));
@@ -9826,7 +10112,7 @@ internal static bool IsRightAssociative(SyntaxKind op)
             }
         }
 
-        enum Precedence : uint
+        private enum Precedence : uint
         {
             Expression = 0, // Loosest possible precedence, used to accept all expressions
             Assignment = Expression,
@@ -10421,9 +10707,9 @@ private ExpressionSyntax ParseTermWithoutPostfix(Precedence precedence)
                         {
                             return this.ParseAnonymousMethodExpression();
                         }
-                        else if (this.IsPossibleLambdaExpression(precedence))
+                        else if (this.IsPossibleLambdaExpression(precedence) && this.TryParseLambdaExpression() is { } lambda)
                         {
-                            return this.ParseLambdaExpression();
+                            return lambda;
                         }
                         else if (this.IsPossibleDeconstructionLeft(precedence))
                         {
@@ -10462,20 +10748,42 @@ private ExpressionSyntax ParseTermWithoutPostfix(Precedence precedence)
                 case SyntaxKind.InterpolatedStringToken:
                     return this.ParseInterpolatedStringToken();
                 case SyntaxKind.OpenParenToken:
-                    return this.ParseCastOrParenExpressionOrLambdaOrTuple(precedence);
+                    if (IsPossibleLambdaExpression(precedence))
+                    {
+                        if (this.TryParseLambdaExpression() is { } lambda)
+                        {
+                            return lambda;
+                        }
+                    }
+                    return this.ParseCastOrParenExpressionOrTuple();
                 case SyntaxKind.NewKeyword:
                     return this.ParseNewExpression();
                 case SyntaxKind.StackAllocKeyword:
                     return this.ParseStackAllocExpression();
                 case SyntaxKind.DelegateKeyword:
+                    // check for lambda expression with explicit function pointer return type
+                    if (this.IsPossibleLambdaExpression(precedence))
+                    {
+                        return this.ParseLambdaExpression();
+                    }
                     return this.ParseAnonymousMethodExpression();
                 case SyntaxKind.RefKeyword:
+                    // check for lambda expression with explicit ref return type: `ref int () => { ... }`
+                    if (this.IsPossibleLambdaExpression(precedence))
+                    {
+                        return this.ParseLambdaExpression();
+                    }
                     // ref is not expected to appear in this position.
                     return this.AddError(ParsePossibleRefExpression(), ErrorCode.ERR_InvalidExprTerm, SyntaxFacts.GetText(tk));
                 default:
-                    // check for intrinsic type followed by '.'
                     if (IsPredefinedType(tk))
                     {
+                        if (this.IsPossibleLambdaExpression(precedence))
+                        {
+                            return this.ParseLambdaExpression();
+                        }
+
+                        // check for intrinsic type followed by '.'
                         var expr = _syntaxFactory.PredefinedType(this.EatToken());
 
                         if (this.CurrentToken.Kind != SyntaxKind.DotToken || tk == SyntaxKind.VoidKeyword)
@@ -10587,7 +10895,8 @@ private bool IsPossibleAnonymousMethodExpression()
                 tokenIndex++;
             }
 
-            return this.PeekToken(tokenIndex).Kind == SyntaxKind.DelegateKeyword;
+            return this.PeekToken(tokenIndex).Kind == SyntaxKind.DelegateKeyword &&
+                this.PeekToken(tokenIndex + 1).Kind != SyntaxKind.AsteriskToken;
         }
 
         private ExpressionSyntax ParsePostFixExpression(ExpressionSyntax expr)
@@ -11139,21 +11448,15 @@ private bool ScanExplicitlyTypedLambda(Precedence precedence)
             var resetPoint = this.GetResetPoint();
             try
             {
-                bool foundParameterModifier = false;
-
-                // do we have the following, possibly with attributes before the parameter:
-                //   case 1: ( T x , ... ) =>
-                //   case 2: ( T x ) =>
-                //   case 3: ( out T x,
-                //   case 4: ( ref T x,
-                //   case 5: ( out T x ) =>
-                //   case 6: ( ref T x ) =>
-                //   case 7: ( in T x ) =>
+                // Do we have the following, where the attributes, modifier, and type are
+                // optional? If so then parse it as a lambda.
+                //   (attributes modifier T x [, ...]) =>
                 //
-                // if so then parse it as a lambda
-
-                // Note: in the first two cases, we cannot distinguish a lambda from a tuple expression
-                // containing declaration expressions, so we scan forwards to the `=>` so we know for sure.
+                // It's not sufficient to assume this is a lambda expression if we see a
+                // modifier such as `(ref x,` because the caller of this method may have
+                // scanned past a preceding identifier, and `F (ref x,` might be a call to
+                // method F rather than a lambda expression with return type F.
+                // Instead, we need to scan to `=>`.
 
                 while (true)
                 {
@@ -11162,13 +11465,12 @@ private bool ScanExplicitlyTypedLambda(Precedence precedence)
 
                     _ = ParseAttributeDeclarations();
 
-                    // Eat 'out' or 'ref' for cases [3, 6]. Even though not allowed in a lambda,
+                    // Eat 'out', 'ref', and 'in'. Even though not allowed in a lambda,
                     // we treat `params` similarly for better error recovery.
                     switch (this.CurrentToken.Kind)
                     {
                         case SyntaxKind.RefKeyword:
                             this.EatToken();
-                            foundParameterModifier = true;
                             if (this.CurrentToken.Kind == SyntaxKind.ReadOnlyKeyword)
                             {
                                 this.EatToken();
@@ -11178,15 +11480,9 @@ private bool ScanExplicitlyTypedLambda(Precedence precedence)
                         case SyntaxKind.InKeyword:
                         case SyntaxKind.ParamsKeyword:
                             this.EatToken();
-                            foundParameterModifier = true;
                             break;
                     }
 
-                    if (this.CurrentToken.Kind == SyntaxKind.EndOfFileToken)
-                    {
-                        return foundParameterModifier;
-                    }
-
                     // NOTE: advances CurrentToken
                     if (this.ScanType() == ScanTypeFlags.NotType)
                     {
@@ -11201,15 +11497,7 @@ private bool ScanExplicitlyTypedLambda(Precedence precedence)
 
                     switch (this.CurrentToken.Kind)
                     {
-                        case SyntaxKind.EndOfFileToken:
-                            return foundParameterModifier;
-
                         case SyntaxKind.CommaToken:
-                            if (foundParameterModifier)
-                            {
-                                return true;
-                            }
-
                             continue;
 
                         case SyntaxKind.CloseParenToken:
@@ -11227,18 +11515,13 @@ private bool ScanExplicitlyTypedLambda(Precedence precedence)
             }
         }
 
-        private ExpressionSyntax ParseCastOrParenExpressionOrLambdaOrTuple(Precedence precedence)
+        private ExpressionSyntax ParseCastOrParenExpressionOrTuple()
         {
             Debug.Assert(this.CurrentToken.Kind == SyntaxKind.OpenParenToken);
 
             var resetPoint = this.GetResetPoint();
             try
             {
-                if (ScanParenthesizedImplicitlyTypedLambda(precedence))
-                {
-                    return this.ParseLambdaExpression();
-                }
-
                 // We have a decision to make -- is this a cast, or is it a parenthesized
                 // expression?  Because look-ahead is cheap with our token stream, we check
                 // to see if this "looks like" a cast (without constructing any parse trees)
@@ -11257,12 +11540,6 @@ private ExpressionSyntax ParseCastOrParenExpressionOrLambdaOrTuple(Precedence pr
                     }
                 }
 
-                this.Reset(ref resetPoint);
-                if (this.ScanExplicitlyTypedLambda(precedence))
-                {
-                    return this.ParseLambdaExpression();
-                }
-
                 // Doesn't look like a cast, so parse this as a parenthesized expression or tuple.
                 {
                     this.Reset(ref resetPoint);
@@ -11440,160 +11717,127 @@ bool isBinaryPatternKeyword()
             }
         }
 
+        /// <summary>
+        /// Tokens that match the following are considered a possible lambda expression:
+        /// <code>attribute-list* ('async' | 'static')* type? ('(' | identifier) ...</code>
+        /// For better error recovery 'static =>' is also considered a possible lambda expression.
+        /// </summary>
         private bool IsPossibleLambdaExpression(Precedence precedence)
         {
-            // Only call into this if after `static`, '[',  or after a legal identifier.
-            Debug.Assert(
-                this.CurrentToken.Kind is SyntaxKind.StaticKeyword or SyntaxKind.OpenBracketToken ||
-                this.IsTrueIdentifier(this.CurrentToken));
             if (precedence > Precedence.Lambda)
             {
                 return false;
             }
 
-            if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken)
+            var resetPoint = this.GetResetPoint();
+            try
             {
-                var resetPoint = this.GetResetPoint();
-                try
+                if (CurrentToken.Kind == SyntaxKind.OpenBracketToken)
                 {
                     _ = ParseAttributeDeclarations();
-                    return CurrentToken.Kind switch
-                    {
-                        SyntaxKind.StaticKeyword or SyntaxKind.IdentifierToken => IsPossibleLambdaExpressionCore(precedence),
-                        SyntaxKind.OpenParenToken => ScanParenthesizedLambda(precedence),
-                        _ => false,
-                    };
                 }
-                finally
+
+                bool seenStatic;
+                if (this.CurrentToken.Kind == SyntaxKind.StaticKeyword)
                 {
-                    this.Reset(ref resetPoint);
-                    this.Release(ref resetPoint);
+                    EatToken();
+                    seenStatic = true;
+                }
+                else if (this.CurrentToken.ContextualKind == SyntaxKind.AsyncKeyword &&
+                         this.PeekToken(1).Kind == SyntaxKind.StaticKeyword)
+                {
+                    EatToken();
+                    EatToken();
+                    seenStatic = true;
+                }
+                else
+                {
+                    seenStatic = false;
                 }
-            }
-            else
-            {
-                return IsPossibleLambdaExpressionCore(precedence);
-            }
-        }
-
-        private bool IsPossibleLambdaExpressionCore(Precedence precedence)
-        {
-            // Only call into this if after `static` or after a legal identifier.
-            Debug.Assert(
-                this.CurrentToken.Kind == SyntaxKind.StaticKeyword ||
-                this.IsTrueIdentifier(this.CurrentToken));
-            Debug.Assert(precedence <= Precedence.Lambda);
-
-            // If we start with `static` or `async static` then just jump past those and do the
-            // analysis after that point.  Note, we don't just blindly consume `async` in `static
-            // async` because that `async` may not be a modifier (it may just be an identifier) and
-            // we have to figure out what it is.
-
-            int peekIndex;
-            bool seenStatic;
-            if (this.CurrentToken.Kind == SyntaxKind.StaticKeyword)
-            {
-                peekIndex = 1;
-                seenStatic = true;
-            }
-            else if (this.CurrentToken.ContextualKind == SyntaxKind.AsyncKeyword &&
-                     this.PeekToken(1).Kind == SyntaxKind.StaticKeyword)
-            {
-                peekIndex = 2;
-                seenStatic = true;
-            }
-            else
-            {
-                peekIndex = 0;
-                seenStatic = false;
-            }
 
-            if (this.PeekToken(peekIndex).Kind == SyntaxKind.EqualsGreaterThanToken)
-            {
-                // We only got into IsPossibleLambdaExpression if we saw 'static' or an identifier.
-                // So if we're now on => then we must have been on 'static' in order to have moved
-                // past those.
-                Contract.Requires(seenStatic);
+                if (seenStatic)
+                {
+                    if (this.CurrentToken.Kind == SyntaxKind.EqualsGreaterThanToken)
+                    {
+                        // 1. `static =>`
+                        // 2. `async static =>`
 
-                // 1. `static =>`
-                // 2. `async static =>`
+                        // This is an error case, but we have enough code in front of us to be certain
+                        // the user was trying to write a static lambda.
+                        return true;
+                    }
 
-                // This is an error case, but we have enough code in front of us to be certain
-                // the user was trying to write a static lambda.
-                return true;
-            }
+                    if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken)
+                    {
+                        // 1. `static (...
+                        // 2. `async static (...
+                        return true;
+                    }
+                }
 
-            if (this.PeekToken(peekIndex).Kind == SyntaxKind.IdentifierToken &&
-                this.PeekToken(peekIndex + 1).Kind == SyntaxKind.EqualsGreaterThanToken)
-            {
-                // 1. `a => ...`
-                // 1. `static a => ...`
-                // 2. `async static a => ...`
-                return true;
-            }
+                if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken &&
+                    this.PeekToken(1).Kind == SyntaxKind.EqualsGreaterThanToken)
+                {
+                    // 1. `a => ...`
+                    // 1. `static a => ...`
+                    // 2. `async static a => ...`
+                    return true;
+                }
 
-            if (this.PeekToken(peekIndex).Kind == SyntaxKind.OpenParenToken)
-            {
-                // We only got into IsPossibleLambdaExpression if we saw 'static' or an identifier.
-                // So if we're now on ( then we must have been on 'static' in order to have moved
-                // past those.
-                Contract.Requires(seenStatic);
+                // Have checked all the static forms.  And have checked for the basic `a => a` form.  
+                // At this point we have must be on 'async' or an explicit return type for this to still be a lambda.
+                if (this.CurrentToken.ContextualKind == SyntaxKind.AsyncKeyword &&
+                    IsAnonymousFunctionAsyncModifier())
+                {
+                    EatToken();
+                }
 
-                // 1. `static (...
-                // 2. `async static (...
-                return true;
-            }
+                var nestedResetPoint = this.GetResetPoint();
+                try
+                {
+                    var st = ScanType();
+                    if (st == ScanTypeFlags.NotType || this.CurrentToken.Kind != SyntaxKind.OpenParenToken)
+                    {
+                        this.Reset(ref nestedResetPoint);
+                    }
+                }
+                finally
+                {
+                    this.Release(ref nestedResetPoint);
+                }
 
-            // Have checked all the static forms.  And have checked for the basic `a => a` form.  
-            // At this point we have must be on 'async' for this to still be a lambda.
-            if (this.PeekToken(peekIndex).ContextualKind != SyntaxKind.AsyncKeyword)
-            {
-                return false;
-            }
+                // However, just because we're on `async` doesn't mean we're a lambda.  We might have
+                // something lambda-like like:
+                //
+                //      async a => ...  // or
+                //      async (a) => ...
+                //
+                // Or we could have something that isn't a lambda like:
+                //
+                //      async ();
 
-            peekIndex++;
-            // However, just because we're on `async` doesn't mean we're a lambda.  We might have
-            // something lambda-like like:
-            //
-            //      async a => ...  // or
-            //      async (a) => ...
-            //
-            // Or we could have something that isn't a lambda like:
-            //
-            //      async ();
+                // 'async <identifier> => ...' looks like an async simple lambda
+                if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken &&
+                    this.PeekToken(1).Kind == SyntaxKind.EqualsGreaterThanToken)
+                {
+                    // async a => ...
+                    return true;
+                }
 
-            // 'async <identifier> => ...' looks like an async simple lambda
-            if (this.PeekToken(peekIndex).Kind == SyntaxKind.IdentifierToken &&
-                this.PeekToken(peekIndex + 1).Kind == SyntaxKind.EqualsGreaterThanToken)
-            {
-                // async a => ...
-                return true;
-            }
+                // Non-simple async lambda must be of the form 'async (...'
+                if (this.CurrentToken.Kind != SyntaxKind.OpenParenToken)
+                {
+                    return false;
+                }
 
-            // Non-simple async lambda must be of the form 'async (...'
-            if (this.PeekToken(peekIndex).Kind != SyntaxKind.OpenParenToken)
-            {
-                return false;
+                // Check whether looks like implicitly or explicitly typed lambda
+                return ScanParenthesizedLambda(precedence);
             }
-
-            // we have `async (`.  Could be a lambda, or could be an invocation of something called
-            // `async`.  Have to do a more costly speculative scan to find out.
-            var resetPoint = this.GetResetPoint();
-
-            // Skip all tokens until we go past 'async'
-            for (int i = 0; i < peekIndex; i++)
+            finally
             {
-                EatToken();
+                this.Reset(ref resetPoint);
+                this.Release(ref resetPoint);
             }
-
-            // Check whether looks like implicitly or explicitly typed lambda
-            bool isAsync = ScanParenthesizedLambda(precedence);
-
-            // Restore current token index
-            this.Reset(ref resetPoint);
-            this.Release(ref resetPoint);
-
-            return isAsync;
         }
 
         private static bool CanFollowCast(SyntaxKind kind)
@@ -12388,7 +12632,7 @@ private SyntaxList<SyntaxToken> ParseAnonymousFunctionModifiers()
                 }
 
                 if (this.CurrentToken.ContextualKind == SyntaxKind.AsyncKeyword &&
-                    this.PeekToken(1).Kind != SyntaxKind.EqualsGreaterThanToken)
+                    IsAnonymousFunctionAsyncModifier())
                 {
                     var asyncToken = this.EatContextualToken(SyntaxKind.AsyncKeyword);
                     asyncToken = CheckFeatureAvailability(asyncToken, MessageID.IDS_FeatureAsync);
@@ -12404,6 +12648,50 @@ private SyntaxList<SyntaxToken> ParseAnonymousFunctionModifiers()
             return result;
         }
 
+        private bool IsAnonymousFunctionAsyncModifier()
+        {
+            Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.AsyncKeyword);
+
+            switch (this.PeekToken(1).Kind)
+            {
+                case SyntaxKind.OpenParenToken:
+                case SyntaxKind.IdentifierToken:
+                case SyntaxKind.StaticKeyword:
+                case SyntaxKind.RefKeyword:
+                case SyntaxKind.DelegateKeyword:
+                    return true;
+                case var kind:
+                    return IsPredefinedType(kind);
+            };
+        }
+
+        /// <summary>
+        /// Parse expected lambda expression but assume `x ? () => y :` is a conditional
+        /// expression rather than a lambda expression with an explicit return type and
+        /// return null in that case only.
+        /// </summary>
+        private LambdaExpressionSyntax TryParseLambdaExpression()
+        {
+            var resetPoint = this.GetResetPoint();
+            try
+            {
+                var result = ParseLambdaExpression();
+
+                if (this.CurrentToken.Kind == SyntaxKind.ColonToken &&
+                    result is ParenthesizedLambdaExpressionSyntax { ReturnType: NullableTypeSyntax { } })
+                {
+                    this.Reset(ref resetPoint);
+                    return null;
+                }
+
+                return result;
+            }
+            finally
+            {
+                this.Release(ref resetPoint);
+            }
+        }
+
         private LambdaExpressionSyntax ParseLambdaExpression()
         {
             var attributes = ParseAttributeDeclarations();
@@ -12420,6 +12708,22 @@ LambdaExpressionSyntax parseLambdaExpressionWorker()
                     this.IsInAsync = true;
                 }
 
+                TypeSyntax returnType;
+                var resetPoint = this.GetResetPoint();
+                try
+                {
+                    returnType = ParseReturnType();
+                    if (CurrentToken.Kind != SyntaxKind.OpenParenToken)
+                    {
+                        this.Reset(ref resetPoint);
+                        returnType = null;
+                    }
+                }
+                finally
+                {
+                    this.Release(ref resetPoint);
+                }
+
                 if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken)
                 {
                     var paramList = this.ParseLambdaParameterList();
@@ -12428,7 +12732,7 @@ LambdaExpressionSyntax parseLambdaExpressionWorker()
                     var (block, expression) = ParseLambdaBody();
 
                     return _syntaxFactory.ParenthesizedLambdaExpression(
-                        attributes, modifiers, paramList, arrow, block, expression);
+                        attributes, modifiers, returnType, paramList, arrow, block, expression);
                 }
                 else
                 {
diff --git a/src/Compilers/CSharp/Portable/Parser/Lexer.cs b/src/Compilers/CSharp/Portable/Parser/Lexer.cs
index ea6e89a6cdfb9..42af25f897c20 100644
--- a/src/Compilers/CSharp/Portable/Parser/Lexer.cs
+++ b/src/Compilers/CSharp/Portable/Parser/Lexer.cs
@@ -2836,6 +2836,11 @@ private bool ScanDirectiveToken(ref TokenInfo info)
                     info.Kind = SyntaxKind.CommaToken;
                     break;
 
+                case '-':
+                    TextWindow.AdvanceChar();
+                    info.Kind = SyntaxKind.MinusToken;
+                    break;
+
                 case '!':
                     TextWindow.AdvanceChar();
                     if (TextWindow.PeekChar() == '=')
diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
index 38ba78915b5c3..2e4228358c428 100644
--- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
@@ -1,6 +1,9 @@
 Microsoft.CodeAnalysis.CSharp.Conversion.IsInterpolatedStringHandler.get -> bool
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp10 = 1000 -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax
@@ -8,17 +11,66 @@ Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Character.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.CommaToken.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Line.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.SyntaxToken character, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCharacter(Microsoft.CodeAnalysis.SyntaxToken character) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken commaToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken line) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+*REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
+*REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken lineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.CharacterOffset.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.End.get -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.MinusToken.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Start.get -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.SyntaxToken minusToken, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, Microsoft.CodeAnalysis.SyntaxToken characterOffset, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithCharacterOffset(Microsoft.CodeAnalysis.SyntaxToken characterOffset) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEnd(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken lineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithMinusToken(Microsoft.CodeAnalysis.SyntaxToken minusToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithStart(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.ExpressionColon.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax expressionColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax expressionColon) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionColon = 9069 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
+Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineDirectivePosition = 9070 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
+Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineSpanDirectiveTrivia = 9071 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordStructDeclaration = 9068 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetUsedAssemblyReferences(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.MetadataReference>
 override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
 override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
 override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
 override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.IsActive.get -> bool
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
@@ -27,11 +79,20 @@ abstract Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AttributeLi
 Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
 override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken character) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.SyntaxToken character, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.SyntaxToken minusToken, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, Microsoft.CodeAnalysis.SyntaxToken characterOffset, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, Microsoft.CodeAnalysis.SyntaxToken characterOffset, Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
@@ -51,6 +112,21 @@ Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.GlobalKeyword.get -> M
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken globalKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithGlobalKeyword(Microsoft.CodeAnalysis.SyntaxToken globalKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax node) -> void
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax node) -> TResult
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax node) -> TResult
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax node) -> TResult
 *REMOVED*Microsoft.CodeAnalysis.CSharp.SyntaxKind.DataKeyword = 8441 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineMappings(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.LineMapping>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
+static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(params Microsoft.CodeAnalysis.IIncrementalGenerator[] incrementalGenerators) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver
diff --git a/src/Compilers/CSharp/Portable/SourceGeneration/CSharpGeneratorDriver.cs b/src/Compilers/CSharp/Portable/SourceGeneration/CSharpGeneratorDriver.cs
index d32e0e3a1ed34..e9858fb922c4e 100644
--- a/src/Compilers/CSharp/Portable/SourceGeneration/CSharpGeneratorDriver.cs
+++ b/src/Compilers/CSharp/Portable/SourceGeneration/CSharpGeneratorDriver.cs
@@ -6,6 +6,7 @@
 using System.Collections.Immutable;
 using System.Threading;
 using Microsoft.CodeAnalysis.Diagnostics;
+using System.Linq;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -22,7 +23,7 @@ public sealed class CSharpGeneratorDriver : GeneratorDriver
         /// <param name="optionsProvider">An <see cref="AnalyzerConfigOptionsProvider"/> that can be used to retrieve analyzer config values by the generators in this driver.</param>
         /// <param name="additionalTexts">A list of <see cref="AdditionalText"/>s available to generators in this driver.</param>
         internal CSharpGeneratorDriver(CSharpParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider optionsProvider, ImmutableArray<AdditionalText> additionalTexts)
-            : base(parseOptions, generators, optionsProvider, additionalTexts)
+            : base(parseOptions, generators, optionsProvider, additionalTexts, enableIncremental: parseOptions.LanguageVersion == LanguageVersion.Preview)
         {
         }
 
@@ -39,6 +40,14 @@ private CSharpGeneratorDriver(GeneratorDriverState state)
         public static CSharpGeneratorDriver Create(params ISourceGenerator[] generators)
             => Create(generators, additionalTexts: null);
 
+        /// <summary>
+        /// Creates a new instance of <see cref="CSharpGeneratorDriver"/> with the specified <see cref="IIncrementalGenerator"/>s and default options
+        /// </summary>
+        /// <param name="incrementalGenerators">The incremental generators to create this driver with</param>
+        /// <returns>A new <see cref="CSharpGeneratorDriver"/> instance.</returns>
+        public static CSharpGeneratorDriver Create(params IIncrementalGenerator[] incrementalGenerators)
+            => Create(incrementalGenerators.Select(GeneratorExtensions.AsSourceGenerator), additionalTexts: null);
+
         /// <summary>
         /// Creates a new instance of <see cref="CSharpGeneratorDriver"/> with the specified <see cref="ISourceGenerator"/>s and the provided options or default.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs b/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs
index 5ab17c17f5e6a..5b806987fc8cc 100644
--- a/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs
+++ b/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs
@@ -477,6 +477,29 @@ public override void VisitMethod(IMethodSymbol symbol)
                 case MethodKind.ExplicitInterfaceImplementation:
                     {
                         AddExplicitInterfaceIfRequired(symbol.ExplicitInterfaceImplementations);
+
+                        if (!format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.UseMetadataMethodNames) &&
+                            symbol.GetSymbol()?.OriginalDefinition is SourceUserDefinedOperatorSymbolBase sourceUserDefinedOperatorSymbolBase)
+                        {
+                            var operatorName = symbol.MetadataName;
+                            var lastDotPosition = operatorName.LastIndexOf('.');
+
+                            if (lastDotPosition >= 0)
+                            {
+                                operatorName = operatorName.Substring(lastDotPosition + 1);
+                            }
+
+                            if (sourceUserDefinedOperatorSymbolBase is SourceUserDefinedConversionSymbol)
+                            {
+                                addUserDefinedConversionName(symbol, operatorName);
+                            }
+                            else
+                            {
+                                addUserDefinedOperatorName(symbol, operatorName);
+                            }
+                            break;
+                        }
+
                         builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol,
                             ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(symbol.Name)));
                         break;
@@ -490,21 +513,7 @@ public override void VisitMethod(IMethodSymbol symbol)
                         }
                         else
                         {
-                            AddKeyword(SyntaxKind.OperatorKeyword);
-                            AddSpace();
-                            if (symbol.MetadataName == WellKnownMemberNames.TrueOperatorName)
-                            {
-                                AddKeyword(SyntaxKind.TrueKeyword);
-                            }
-                            else if (symbol.MetadataName == WellKnownMemberNames.FalseOperatorName)
-                            {
-                                AddKeyword(SyntaxKind.FalseKeyword);
-                            }
-                            else
-                            {
-                                builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol,
-                                    SyntaxFacts.GetText(SyntaxFacts.GetOperatorKind(symbol.MetadataName))));
-                            }
+                            addUserDefinedOperatorName(symbol, symbol.MetadataName);
                         }
                         break;
                     }
@@ -516,26 +525,7 @@ public override void VisitMethod(IMethodSymbol symbol)
                         }
                         else
                         {
-                            // "System.IntPtr.explicit operator System.IntPtr(int)"
-
-                            if (symbol.MetadataName == WellKnownMemberNames.ExplicitConversionName)
-                            {
-                                AddKeyword(SyntaxKind.ExplicitKeyword);
-                            }
-                            else if (symbol.MetadataName == WellKnownMemberNames.ImplicitConversionName)
-                            {
-                                AddKeyword(SyntaxKind.ImplicitKeyword);
-                            }
-                            else
-                            {
-                                builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol,
-                                    SyntaxFacts.GetText(SyntaxFacts.GetOperatorKind(symbol.MetadataName))));
-                            }
-
-                            AddSpace();
-                            AddKeyword(SyntaxKind.OperatorKeyword);
-                            AddSpace();
-                            AddReturnType(symbol);
+                            addUserDefinedConversionName(symbol, symbol.MetadataName);
                         }
                         break;
                     }
@@ -638,6 +628,50 @@ void visitFunctionPointerSignature(IMethodSymbol symbol)
 
                 AddPunctuation(SyntaxKind.GreaterThanToken);
             }
+
+            void addUserDefinedOperatorName(IMethodSymbol symbol, string operatorName)
+            {
+                AddKeyword(SyntaxKind.OperatorKeyword);
+                AddSpace();
+
+                if (operatorName == WellKnownMemberNames.TrueOperatorName)
+                {
+                    AddKeyword(SyntaxKind.TrueKeyword);
+                }
+                else if (operatorName == WellKnownMemberNames.FalseOperatorName)
+                {
+                    AddKeyword(SyntaxKind.FalseKeyword);
+                }
+                else
+                {
+                    builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol,
+                        SyntaxFacts.GetText(SyntaxFacts.GetOperatorKind(operatorName))));
+                }
+            }
+
+            void addUserDefinedConversionName(IMethodSymbol symbol, string operatorName)
+            {
+                // "System.IntPtr.explicit operator System.IntPtr(int)"
+
+                if (operatorName == WellKnownMemberNames.ExplicitConversionName)
+                {
+                    AddKeyword(SyntaxKind.ExplicitKeyword);
+                }
+                else if (operatorName == WellKnownMemberNames.ImplicitConversionName)
+                {
+                    AddKeyword(SyntaxKind.ImplicitKeyword);
+                }
+                else
+                {
+                    builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol,
+                        SyntaxFacts.GetText(SyntaxFacts.GetOperatorKind(operatorName))));
+                }
+
+                AddSpace();
+                AddKeyword(SyntaxKind.OperatorKeyword);
+                AddSpace();
+                AddReturnType(symbol);
+            }
         }
 
         private static SymbolDisplayPartKind GetPartKindForConstructorOrDestructor(IMethodSymbol symbol)
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/PublicSymbols/AnonymousType.TypePublicSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/PublicSymbols/AnonymousType.TypePublicSymbol.cs
index b50f425d62c1d..d06768b9dd9cd 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/PublicSymbols/AnonymousType.TypePublicSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/PublicSymbols/AnonymousType.TypePublicSymbol.cs
@@ -350,6 +350,11 @@ public override int GetHashCode()
             }
 
             internal override bool HasPossibleWellKnownCloneMethod() => false;
+
+            internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+            {
+                return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+            }
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.ConstructorSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.ConstructorSymbol.cs
index 8abc613b9ccdc..abd52b0b285c8 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.ConstructorSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.ConstructorSymbol.cs
@@ -6,6 +6,7 @@
 
 using System;
 using System.Collections.Immutable;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -25,13 +26,13 @@ internal AnonymousTypeConstructorSymbol(NamedTypeSymbol container, ImmutableArra
                 int fieldsCount = properties.Length;
                 if (fieldsCount > 0)
                 {
-                    ParameterSymbol[] paramsArr = new ParameterSymbol[fieldsCount];
+                    var paramsArr = ArrayBuilder<ParameterSymbol>.GetInstance(fieldsCount);
                     for (int index = 0; index < fieldsCount; index++)
                     {
                         PropertySymbol property = properties[index];
-                        paramsArr[index] = SynthesizedParameterSymbol.Create(this, property.TypeWithAnnotations, index, RefKind.None, property.Name);
+                        paramsArr.Add(SynthesizedParameterSymbol.Create(this, property.TypeWithAnnotations, index, RefKind.None, property.Name));
                     }
-                    _parameters = paramsArr.AsImmutableOrNull();
+                    _parameters = paramsArr.ToImmutableAndFree();
                 }
                 else
                 {
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TemplateSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TemplateSymbol.cs
index 98dd732571288..328d7f9663bcb 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TemplateSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TemplateSymbol.cs
@@ -513,6 +513,11 @@ private SynthesizedAttributeData TrySynthesizeDebuggerDisplayAttribute()
             }
 
             internal override bool HasPossibleWellKnownCloneMethod() => false;
+
+            internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+            {
+                return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+            }
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/ArrayTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ArrayTypeSymbol.cs
index b6522f35a068b..cc5e6a277f9b4 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ArrayTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/ArrayTypeSymbol.cs
@@ -483,6 +483,11 @@ protected sealed override ITypeSymbol CreateITypeSymbol(CodeAnalysis.NullableAnn
 
         internal override bool IsRecordStruct => false;
 
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
+
         /// <summary>
         /// Represents SZARRAY - zero-based one-dimensional array 
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/Symbols/AssemblySymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AssemblySymbol.cs
index 97bbfad9de5f1..b72a47fb05017 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AssemblySymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/AssemblySymbol.cs
@@ -431,6 +431,15 @@ internal bool RuntimeSupportsDefaultInterfaceImplementation
             get => RuntimeSupportsFeature(SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__DefaultImplementationsOfInterfaces);
         }
 
+        /// <summary>
+        /// Figure out if the target runtime supports static abstract members in interfaces.
+        /// </summary>
+        internal bool RuntimeSupportsStaticAbstractMembersInInterfaces
+        {
+            // https://github.com/dotnet/roslyn/issues/53800: Implement the actual check, this is a temporary stub. 
+            get => RuntimeSupportsDefaultInterfaceImplementation;
+        }
+
         private bool RuntimeSupportsFeature(SpecialMember feature)
         {
             Debug.Assert((SpecialType)SpecialMembers.GetDescriptor(feature).DeclaringTypeId == SpecialType.System_Runtime_CompilerServices_RuntimeFeature);
diff --git a/src/Compilers/CSharp/Portable/Symbols/ConstraintsHelper.cs b/src/Compilers/CSharp/Portable/Symbols/ConstraintsHelper.cs
index d7c69e35c3db2..037055b74e898 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ConstraintsHelper.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/ConstraintsHelper.cs
@@ -1056,7 +1056,20 @@ private static void CheckConstraintType(
             ErrorCode errorCode;
             if (typeArgument.Type.IsReferenceType)
             {
-                errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedRefType;
+                // When constraint has static abstract members this needs to be further restricted so that generic argument cannot itself be an interface.
+                if (typeArgument.Type.IsInterfaceType() && constraintType.Type.IsInterfaceType() &&
+                    args.Conversions.WithNullability(false).HasIdentityOrImplicitReferenceConversion(typeArgument.Type, constraintType.Type, ref useSiteInfo))
+                {
+#if DEBUG
+                    var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
+                    Debug.Assert(SelfOrBaseHasStaticAbstractMember(constraintType, ref discardedUseSiteInfo));
+#endif
+                    errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers;
+                }
+                else
+                {
+                    errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedRefType;
+                }
             }
             else if (typeArgument.IsNullableType())
             {
@@ -1071,8 +1084,22 @@ private static void CheckConstraintType(
                 errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedValType;
             }
 
-            SymbolDistinguisher distinguisher = new SymbolDistinguisher(args.CurrentCompilation, constraintType.Type, typeArgument.Type);
-            diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(errorCode, containingSymbol.ConstructedFrom(), distinguisher.First, typeParameter, distinguisher.Second))));
+            object constraintTypeErrorArgument;
+            object typeArgumentErrorArgument;
+
+            if (constraintType.Type.Equals(typeArgument.Type, TypeCompareKind.AllIgnoreOptions))
+            {
+                constraintTypeErrorArgument = constraintType.Type;
+                typeArgumentErrorArgument = typeArgument.Type;
+            }
+            else
+            {
+                SymbolDistinguisher distinguisher = new SymbolDistinguisher(args.CurrentCompilation, constraintType.Type, typeArgument.Type);
+                constraintTypeErrorArgument = distinguisher.First;
+                typeArgumentErrorArgument = distinguisher.Second;
+            }
+
+            diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(errorCode, containingSymbol.ConstructedFrom(), constraintTypeErrorArgument, typeParameter, typeArgumentErrorArgument))));
             hasError = true;
 
             static NullableFlowState getTypeArgumentState(in TypeWithAnnotations typeWithAnnotations)
@@ -1212,6 +1239,13 @@ private static bool SatisfiesConstraintType(
 
             if (conversions.HasIdentityOrImplicitReferenceConversion(typeArgument.Type, constraintType.Type, ref useSiteInfo))
             {
+                // When constraint has static abstract members this needs to be further restricted so that generic argument cannot itself be an interface.
+                if (typeArgument.Type.IsInterfaceType() && constraintType.Type.IsInterfaceType() &&
+                    SelfOrBaseHasStaticAbstractMember(constraintType, ref useSiteInfo))
+                {
+                    return false;
+                }
+
                 return true;
             }
 
@@ -1249,6 +1283,32 @@ private static bool SatisfiesConstraintType(
             return false;
         }
 
+        private static bool SelfOrBaseHasStaticAbstractMember(TypeWithAnnotations constraintType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        {
+            Debug.Assert(constraintType.Type.IsInterfaceType());
+
+            Func<Symbol, bool> predicate = static m => m.IsStatic && m.IsAbstract;
+            var definition = (NamedTypeSymbol)constraintType.Type.OriginalDefinition;
+
+            if (definition.GetMembersUnordered().Any(predicate))
+            {
+                return true;
+            }
+
+            foreach (var baseInterface in definition.InterfacesAndTheirBaseInterfacesNoUseSiteDiagnostics.Keys)
+            {
+                var baseDefinition = baseInterface.OriginalDefinition;
+                if (baseDefinition.GetMembersUnordered().Any(predicate))
+                {
+                    return true;
+                }
+
+                baseDefinition.AddUseSiteInfo(ref useSiteInfo);
+            }
+
+            return false;
+        }
+
         private static bool IsReferenceType(TypeParameterSymbol typeParameter, ImmutableArray<TypeWithAnnotations> constraintTypes)
         {
             return typeParameter.HasReferenceTypeConstraint || TypeParameterSymbol.CalculateIsReferenceTypeFromConstraintTypes(constraintTypes);
diff --git a/src/Compilers/CSharp/Portable/Symbols/DynamicTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/DynamicTypeSymbol.cs
index f58b18e71e109..4f4733a2b68dd 100644
--- a/src/Compilers/CSharp/Portable/Symbols/DynamicTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/DynamicTypeSymbol.cs
@@ -248,5 +248,10 @@ protected sealed override ITypeSymbol CreateITypeSymbol(CodeAnalysis.NullableAnn
         internal override bool IsRecord => false;
 
         internal override bool IsRecordStruct => false;
+
+        internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs
index d8b4aaef1ffcc..df62ab4c46572 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs
@@ -548,6 +548,11 @@ protected sealed override ITypeSymbol CreateITypeSymbol(CodeAnalysis.NullableAnn
         internal sealed override bool IsRecord => false;
         internal override bool IsRecordStruct => false;
         internal sealed override bool HasPossibleWellKnownCloneMethod() => false;
+
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
     }
 
     internal abstract class SubstitutedErrorTypeSymbol : ErrorTypeSymbol
diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs
index c06a0a0acd1be..e54491006c414 100644
--- a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs
@@ -216,5 +216,10 @@ internal static bool IsCallingConventionModifier(NamedTypeSymbol modifierType)
         internal override bool IsRecord => false;
 
         internal override bool IsRecordStruct => false;
+
+        internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/MemberSignatureComparer.cs b/src/Compilers/CSharp/Portable/Symbols/MemberSignatureComparer.cs
index f9a9cf690c1e0..7868ec311522c 100644
--- a/src/Compilers/CSharp/Portable/Symbols/MemberSignatureComparer.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/MemberSignatureComparer.cs
@@ -234,6 +234,18 @@ internal sealed class MemberSignatureComparer : IEqualityComparer<Symbol>
             considerRefKindDifferences: false,
             typeComparison: TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreNativeIntegers);
 
+        /// <summary>
+        /// Same as <see cref="RuntimeSignatureComparer"/>, but in addition ignores name.
+        /// </summary>
+        public static readonly MemberSignatureComparer RuntimeExplicitImplementationSignatureComparer = new MemberSignatureComparer(
+            considerName: false,
+            considerExplicitlyImplementedInterfaces: false,
+            considerReturnType: true,
+            considerTypeConstraints: false,
+            considerCallingConvention: true,
+            considerRefKindDifferences: false,
+            typeComparison: TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreNativeIntegers);
+
         /// <summary>
         /// Same as <see cref="RuntimeSignatureComparer"/>, but distinguishes between <c>ref</c> and <c>out</c>. During override resolution,
         /// if we find two methods that match except for <c>ref</c>/<c>out</c>, we want to prefer the one that matches, even
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/MemberRefMetadataDecoder.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/MemberRefMetadataDecoder.cs
index c7e557d1d6f55..027115bf4bc27 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/MemberRefMetadataDecoder.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/MemberRefMetadataDecoder.cs
@@ -25,7 +25,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE
     internal sealed class MemberRefMetadataDecoder : MetadataDecoder
     {
         /// <summary>
-        /// Type context for resolving generic type arguments.
+        /// Type context for resolving generic type parameters.
         /// </summary>
         private readonly TypeSymbol _containingType;
 
@@ -52,40 +52,25 @@ protected override TypeSymbol GetGenericMethodTypeParamSymbol(int position)
         }
 
         /// <summary>
-        /// This override changes two things:
-        ///     1) Return type arguments instead of type parameters.
-        ///     2) Handle non-PE types.
+        /// This override can handle non-PE types.
         /// </summary>
         protected override TypeSymbol GetGenericTypeParamSymbol(int position)
         {
             PENamedTypeSymbol peType = _containingType as PENamedTypeSymbol;
             if ((object)peType != null)
             {
-                while ((object)peType != null && (peType.MetadataArity - peType.Arity) > position)
-                {
-                    peType = peType.ContainingSymbol as PENamedTypeSymbol;
-                }
-
-                if ((object)peType == null || peType.MetadataArity <= position)
-                {
-                    return new UnsupportedMetadataTypeSymbol(); // position of type parameter too large
-                }
-
-                position -= peType.MetadataArity - peType.Arity;
-                Debug.Assert(position >= 0 && position < peType.Arity);
-
-                return peType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[position].Type; //NB: args, not params
+                return base.GetGenericTypeParamSymbol(position);
             }
 
             NamedTypeSymbol namedType = _containingType as NamedTypeSymbol;
             if ((object)namedType != null)
             {
                 int cumulativeArity;
-                TypeSymbol typeArgument;
-                GetGenericTypeArgumentSymbol(position, namedType, out cumulativeArity, out typeArgument);
-                if ((object)typeArgument != null)
+                TypeParameterSymbol typeParameter;
+                GetGenericTypeParameterSymbol(position, namedType, out cumulativeArity, out typeParameter);
+                if ((object)typeParameter != null)
                 {
-                    return typeArgument;
+                    return typeParameter;
                 }
                 else
                 {
@@ -97,7 +82,7 @@ protected override TypeSymbol GetGenericTypeParamSymbol(int position)
             return new UnsupportedMetadataTypeSymbol(); // associated type does not have type parameters
         }
 
-        private static void GetGenericTypeArgumentSymbol(int position, NamedTypeSymbol namedType, out int cumulativeArity, out TypeSymbol typeArgument)
+        private static void GetGenericTypeParameterSymbol(int position, NamedTypeSymbol namedType, out int cumulativeArity, out TypeParameterSymbol typeArgument)
         {
             cumulativeArity = namedType.Arity;
             typeArgument = null;
@@ -108,7 +93,7 @@ private static void GetGenericTypeArgumentSymbol(int position, NamedTypeSymbol n
             if ((object)containingType != null)
             {
                 int containingTypeCumulativeArity;
-                GetGenericTypeArgumentSymbol(position, containingType, out containingTypeCumulativeArity, out typeArgument);
+                GetGenericTypeParameterSymbol(position, containingType, out containingTypeCumulativeArity, out typeArgument);
                 cumulativeArity += containingTypeCumulativeArity;
                 arityOffset = containingTypeCumulativeArity;
             }
@@ -117,25 +102,19 @@ private static void GetGenericTypeArgumentSymbol(int position, NamedTypeSymbol n
             {
                 Debug.Assert((object)typeArgument == null);
 
-                typeArgument = namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[position - arityOffset].Type;
+                typeArgument = namedType.TypeParameters[position - arityOffset];
             }
         }
 
         /// <summary>
-        /// Search through the members of a given type symbol to find the method that matches a particular
+        /// Search through the members of the <see cref="_containingType"/> type symbol to find the method that matches a particular
         /// signature.
         /// </summary>
-        /// <param name="targetTypeSymbol">Type containing the desired method symbol.</param>
         /// <param name="memberRef">A MemberRef handle that can be used to obtain the name and signature of the method</param>
         /// <param name="methodsOnly">True to only return a method.</param>
         /// <returns>The matching method symbol, or null if the inputs do not correspond to a valid method.</returns>
-        internal Symbol FindMember(TypeSymbol targetTypeSymbol, MemberReferenceHandle memberRef, bool methodsOnly)
+        internal Symbol FindMember(MemberReferenceHandle memberRef, bool methodsOnly)
         {
-            if ((object)targetTypeSymbol == null)
-            {
-                return null;
-            }
-
             try
             {
                 string memberName = Module.GetMemberRefNameOrThrow(memberRef);
@@ -150,7 +129,7 @@ internal Symbol FindMember(TypeSymbol targetTypeSymbol, MemberReferenceHandle me
                     case (byte)SignatureCallingConvention.VarArgs:
                         int typeParamCount;
                         ParamInfo<TypeSymbol>[] targetParamInfo = this.DecodeSignatureParametersOrThrow(ref signaturePointer, signatureHeader, out typeParamCount);
-                        return FindMethodBySignature(targetTypeSymbol, memberName, signatureHeader, typeParamCount, targetParamInfo);
+                        return FindMethodBySignature(_containingType, memberName, signatureHeader, typeParamCount, targetParamInfo);
 
                     case (byte)SignatureKind.Field:
                         if (methodsOnly)
@@ -161,7 +140,7 @@ internal Symbol FindMember(TypeSymbol targetTypeSymbol, MemberReferenceHandle me
 
                         ImmutableArray<ModifierInfo<TypeSymbol>> customModifiers;
                         TypeSymbol type = this.DecodeFieldSignature(ref signaturePointer, out customModifiers);
-                        return FindFieldBySignature(targetTypeSymbol, memberName, customModifiers, type);
+                        return FindFieldBySignature(_containingType, memberName, customModifiers, type);
 
                     default:
                         // error: unexpected calling convention
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/MetadataDecoder.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/MetadataDecoder.cs
index 0cb4d8bc019c6..1e11140687379 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/MetadataDecoder.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/MetadataDecoder.cs
@@ -535,9 +535,16 @@ internal override Symbol GetSymbolForMemberRef(MemberReferenceHandle memberRef,
 
             // We're going to use a special decoder that can generate usable symbols for type parameters without full context.
             // (We're not just using a different type - we're also changing the type context.)
-            var memberRefDecoder = new MemberRefMetadataDecoder(moduleSymbol, targetTypeSymbol);
+            var memberRefDecoder = new MemberRefMetadataDecoder(moduleSymbol, targetTypeSymbol.OriginalDefinition);
 
-            return memberRefDecoder.FindMember(targetTypeSymbol, memberRef, methodsOnly);
+            var definition = memberRefDecoder.FindMember(memberRef, methodsOnly);
+
+            if (definition is not null && !targetTypeSymbol.IsDefinition)
+            {
+                return definition.SymbolAsMember((NamedTypeSymbol)targetTypeSymbol);
+            }
+
+            return definition;
         }
 
         protected override void EnqueueTypeSymbolInterfacesAndBaseTypes(Queue<TypeDefinitionHandle> typeDefsToSearch, Queue<TypeSymbol> typeSymbolsToSearch, TypeSymbol typeSymbol)
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEEventSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEEventSymbol.cs
index 0b4736a519dfb..802b89f730d4f 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEEventSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEEventSymbol.cs
@@ -381,7 +381,11 @@ public override ImmutableArray<EventSymbol> ExplicitInterfaceImplementations
                 }
 
                 var implementedEvents = PEPropertyOrEventHelpers.GetEventsForExplicitlyImplementedAccessor(_addMethod);
-                implementedEvents.IntersectWith(PEPropertyOrEventHelpers.GetEventsForExplicitlyImplementedAccessor(_removeMethod));
+
+                if (implementedEvents.Count != 0)
+                {
+                    implementedEvents.IntersectWith(PEPropertyOrEventHelpers.GetEventsForExplicitlyImplementedAccessor(_removeMethod));
+                }
 
                 var builder = ArrayBuilder<EventSymbol>.GetInstance();
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEMethodSymbol.cs
index af3315940e2ce..d79d9b4333fdd 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEMethodSymbol.cs
@@ -1174,18 +1174,17 @@ private MethodKind ComputeMethodKind()
                             return MethodKind.DelegateInvoke;
                         }
                         break;
-                    default:
-                        // Note: this is expensive, so check it last
-                        // Note: method being processed may have an explicit method .override but still be 
-                        //       publicly accessible, the decision here is being made based on the method's name
-                        if (!SyntaxFacts.IsValidIdentifier(this.Name) && !this.ExplicitInterfaceImplementations.IsEmpty)
-                        {
-                            return MethodKind.ExplicitInterfaceImplementation;
-                        }
-                        break;
                 }
             }
 
+            // Note: this is expensive, so check it last
+            // Note: method being processed may have an explicit method .override but still be 
+            //       publicly accessible, the decision here is being made based on the method's name
+            if (!SyntaxFacts.IsValidIdentifier(this.Name) && !this.ExplicitInterfaceImplementations.IsEmpty)
+            {
+                return MethodKind.ExplicitInterfaceImplementation;
+            }
+
             return MethodKind.Ordinary;
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
index 2ae8ee4cca321..14265e8e29469 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
@@ -1874,7 +1874,7 @@ private PooledDictionary<MethodDefinitionHandle, PEMethodSymbol> CreateMethods(A
             {
                 foreach (var methodHandle in module.GetMethodsOfTypeOrThrow(_handle))
                 {
-                    if (isOrdinaryEmbeddableStruct || module.ShouldImportMethod(methodHandle, moduleSymbol.ImportOptions))
+                    if (isOrdinaryEmbeddableStruct || module.ShouldImportMethod(_handle, methodHandle, moduleSymbol.ImportOptions))
                     {
                         var method = new PEMethodSymbol(moduleSymbol, this, methodHandle);
                         members.Add(method);
@@ -1901,8 +1901,8 @@ private void CreateProperties(Dictionary<MethodDefinitionHandle, PEMethodSymbol>
                     {
                         var methods = module.GetPropertyMethodsOrThrow(propertyDef);
 
-                        PEMethodSymbol getMethod = GetAccessorMethod(module, methodHandleToSymbol, methods.Getter);
-                        PEMethodSymbol setMethod = GetAccessorMethod(module, methodHandleToSymbol, methods.Setter);
+                        PEMethodSymbol getMethod = GetAccessorMethod(module, methodHandleToSymbol, _handle, methods.Getter);
+                        PEMethodSymbol setMethod = GetAccessorMethod(module, methodHandleToSymbol, _handle, methods.Setter);
 
                         if (((object)getMethod != null) || ((object)setMethod != null))
                         {
@@ -1934,8 +1934,8 @@ private void CreateEvents(
                         var methods = module.GetEventMethodsOrThrow(eventRid);
 
                         // NOTE: C# ignores all other accessors (most notably, raise/fire).
-                        PEMethodSymbol addMethod = GetAccessorMethod(module, methodHandleToSymbol, methods.Adder);
-                        PEMethodSymbol removeMethod = GetAccessorMethod(module, methodHandleToSymbol, methods.Remover);
+                        PEMethodSymbol addMethod = GetAccessorMethod(module, methodHandleToSymbol, _handle, methods.Adder);
+                        PEMethodSymbol removeMethod = GetAccessorMethod(module, methodHandleToSymbol, _handle, methods.Remover);
 
                         // NOTE: both accessors are required, but that will be reported separately.
                         // Create the symbol unless both accessors are missing.
@@ -1952,7 +1952,7 @@ private void CreateEvents(
             { }
         }
 
-        private PEMethodSymbol GetAccessorMethod(PEModule module, Dictionary<MethodDefinitionHandle, PEMethodSymbol> methodHandleToSymbol, MethodDefinitionHandle methodDef)
+        private PEMethodSymbol GetAccessorMethod(PEModule module, Dictionary<MethodDefinitionHandle, PEMethodSymbol> methodHandleToSymbol, TypeDefinitionHandle typeDef, MethodDefinitionHandle methodDef)
         {
             if (methodDef.IsNil)
             {
@@ -1961,7 +1961,7 @@ private PEMethodSymbol GetAccessorMethod(PEModule module, Dictionary<MethodDefin
 
             PEMethodSymbol method;
             bool found = methodHandleToSymbol.TryGetValue(methodDef, out method);
-            Debug.Assert(found || !module.ShouldImportMethod(methodDef, this.ContainingPEModule.ImportOptions));
+            Debug.Assert(found || !module.ShouldImportMethod(typeDef, methodDef, this.ContainingPEModule.ImportOptions));
             return method;
         }
 
@@ -2316,6 +2316,11 @@ private static IEnumerable<TSymbol> GetMembers<TSymbol>(ImmutableArray<Symbol> m
             }
         }
 
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
+
         /// <summary>
         /// Specialized PENamedTypeSymbol for types with no type parameters in
         /// metadata (no type parameters on this type and all containing types).
diff --git a/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs
index 6c77da950b036..85030a8a2eddf 100644
--- a/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs
@@ -1016,7 +1016,7 @@ internal bool CheckAndReportValidUnmanagedCallersOnlyTarget(Location? location,
         {
             Debug.Assert((location == null) == (diagnostics == null));
 
-            if (!IsStatic || MethodKind is not (MethodKind.Ordinary or MethodKind.LocalFunction))
+            if (!IsStatic || IsAbstract || MethodKind is not (MethodKind.Ordinary or MethodKind.LocalFunction))
             {
                 // `UnmanagedCallersOnly` can only be applied to ordinary static methods or local functions.
                 diagnostics?.Add(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, location!);
diff --git a/src/Compilers/CSharp/Portable/Symbols/MethodSymbolExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/MethodSymbolExtensions.cs
index 6ff5ef7702a84..a194aea394fcc 100644
--- a/src/Compilers/CSharp/Portable/Symbols/MethodSymbolExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/MethodSymbolExtensions.cs
@@ -12,6 +12,7 @@
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using System.Linq;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -146,6 +147,7 @@ private static bool CanBeHiddenByMethodPropertyOrType(MethodSymbol method)
             }
         }
 
+#nullable enable
         /// <summary>
         /// Returns whether this method is async and returns void.
         /// </summary>
@@ -155,21 +157,23 @@ public static bool IsAsyncReturningVoid(this MethodSymbol method)
         }
 
         /// <summary>
-        /// Returns whether this method is async and returns a task.
+        /// Returns whether this method is async and returns a task, task-like, or other type with a method-level builder.
         /// </summary>
-        public static bool IsAsyncReturningTask(this MethodSymbol method, CSharpCompilation compilation)
+        public static bool IsAsyncEffectivelyReturningTask(this MethodSymbol method, CSharpCompilation compilation)
         {
             return method.IsAsync
-                && method.ReturnType.IsNonGenericTaskType(compilation);
+                && method.ReturnType is NamedTypeSymbol { Arity: 0 }
+                && (method.HasAsyncMethodBuilderAttribute(builderArgument: out _) || method.ReturnType.IsNonGenericTaskType(compilation));
         }
 
         /// <summary>
-        /// Returns whether this method is async and returns a generic task.
+        /// Returns whether this method is async and returns a generic task, task-like, or other type with a method-level builder.
         /// </summary>
-        public static bool IsAsyncReturningGenericTask(this MethodSymbol method, CSharpCompilation compilation)
+        public static bool IsAsyncEffectivelyReturningGenericTask(this MethodSymbol method, CSharpCompilation compilation)
         {
             return method.IsAsync
-                && method.ReturnType.IsGenericTaskType(compilation);
+                && method.ReturnType is NamedTypeSymbol { Arity: 1 }
+                && (method.HasAsyncMethodBuilderAttribute(builderArgument: out _) || method.ReturnType.IsGenericTaskType(compilation));
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs
index 010db022dcc0e..ad4ebf2417df2 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs
@@ -254,6 +254,11 @@ internal static void VerifyEquality(Symbol symbolA, Symbol symbolB)
             Debug.Assert(symbolA.GetHashCode() == symbolB.GetHashCode());
         }
 
+        internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
+
         private sealed class NativeIntegerTypeMap : AbstractTypeMap
         {
             private readonly NativeIntegerTypeSymbol _type;
diff --git a/src/Compilers/CSharp/Portable/Symbols/OverriddenOrHiddenMembersHelpers.cs b/src/Compilers/CSharp/Portable/Symbols/OverriddenOrHiddenMembersHelpers.cs
index 799174c54f6a7..2597633084c75 100644
--- a/src/Compilers/CSharp/Portable/Symbols/OverriddenOrHiddenMembersHelpers.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/OverriddenOrHiddenMembersHelpers.cs
@@ -1019,7 +1019,7 @@ internal static MethodSymbol GetFirstRuntimeOverriddenMethodIgnoringNewSlot(this
             const bool ignoreInterfaceImplementationChanges = true;
 
             wasAmbiguous = false;
-            if (!method.IsMetadataVirtual(ignoreInterfaceImplementationChanges))
+            if (!method.IsMetadataVirtual(ignoreInterfaceImplementationChanges) || method.IsStatic)
             {
                 return null;
             }
diff --git a/src/Compilers/CSharp/Portable/Symbols/PointerTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/PointerTypeSymbol.cs
index cdb060d1e39d1..b667cb0b3bbf6 100644
--- a/src/Compilers/CSharp/Portable/Symbols/PointerTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/PointerTypeSymbol.cs
@@ -312,5 +312,10 @@ protected override ITypeSymbol CreateITypeSymbol(CodeAnalysis.NullableAnnotation
         internal override bool IsRecord => false;
 
         internal override bool IsRecordStruct => false;
+
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
index 7c3fa8e2309bd..2c68e1d6d79b5 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
@@ -513,7 +513,7 @@ public override ImmutableArray<ParameterSymbol> Parameters
             {
                 if (_lazyParameters.IsDefault)
                 {
-                    ImmutableInterlocked.InterlockedCompareExchange(ref _lazyParameters, this.MakeParameters(), default(ImmutableArray<ParameterSymbol>));
+                    ImmutableInterlocked.InterlockedInitialize(ref _lazyParameters, this.MakeParameters());
                 }
                 return _lazyParameters;
             }
@@ -557,13 +557,13 @@ private ImmutableArray<ParameterSymbol> MakeParameters()
             }
             else
             {
-                var parameters = new ParameterSymbol[count - 1];
+                var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(count - 1);
                 for (int i = 0; i < count - 1; i++)
                 {
-                    parameters[i] = new ReducedExtensionMethodParameterSymbol(this, reducedFromParameters[i + 1]);
+                    parameters.Add(new ReducedExtensionMethodParameterSymbol(this, reducedFromParameters[i + 1]));
                 }
 
-                return parameters.AsImmutableOrNull();
+                return parameters.ToImmutableAndFree();
             }
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingMethodSymbol.cs
index f51b06545c792..cde90e9074875 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingMethodSymbol.cs
@@ -154,7 +154,7 @@ public override ImmutableArray<ParameterSymbol> Parameters
             {
                 if (_lazyParameters.IsDefault)
                 {
-                    ImmutableInterlocked.InterlockedCompareExchange(ref _lazyParameters, this.RetargetParameters(), default(ImmutableArray<ParameterSymbol>));
+                    ImmutableInterlocked.InterlockedInitialize(ref _lazyParameters, this.RetargetParameters());
                 }
 
                 return _lazyParameters;
@@ -172,14 +172,14 @@ private ImmutableArray<ParameterSymbol> RetargetParameters()
             }
             else
             {
-                ParameterSymbol[] parameters = new ParameterSymbol[count];
+                var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(count);
 
                 for (int i = 0; i < count; i++)
                 {
-                    parameters[i] = new RetargetingMethodParameterSymbol(this, list[i]);
+                    parameters.Add(new RetargetingMethodParameterSymbol(this, list[i]));
                 }
 
-                return parameters.AsImmutableOrNull();
+                return parameters.ToImmutableAndFree();
             }
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs
index 211e8ba1ce1d3..4bd11b5db2f26 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs
@@ -394,5 +394,19 @@ public sealed override bool AreLocalsZeroed
         internal sealed override bool IsRecord => _underlyingType.IsRecord;
         internal sealed override bool IsRecordStruct => _underlyingType.IsRecordStruct;
         internal sealed override bool HasPossibleWellKnownCloneMethod() => _underlyingType.HasPossibleWellKnownCloneMethod();
+
+        internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            foreach ((MethodSymbol body, MethodSymbol implemented) in _underlyingType.SynthesizedInterfaceMethodImpls())
+            {
+                var newBody = this.RetargetingTranslator.Retarget(body, MemberSignatureComparer.RetargetedExplicitImplementationComparer);
+                var newImplemented = this.RetargetingTranslator.Retarget(implemented, MemberSignatureComparer.RetargetedExplicitImplementationComparer);
+
+                if (newBody is object && newImplemented is object)
+                {
+                    yield return (newBody, newImplemented);
+                }
+            }
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingSymbolTranslator.cs b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingSymbolTranslator.cs
index 9cefa14b02a3e..be8ece2a7ba76 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingSymbolTranslator.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingSymbolTranslator.cs
@@ -895,6 +895,8 @@ public MethodSymbol Retarget(MethodSymbol method)
 
             public MethodSymbol Retarget(MethodSymbol method, IEqualityComparer<MethodSymbol> retargetedMethodComparer)
             {
+                Debug.Assert((object)method == method.ConstructedFrom);
+
                 if (ReferenceEquals(method.ContainingModule, this.UnderlyingModule) && ReferenceEquals(method, method.OriginalDefinition))
                 {
                     return Retarget(method);
@@ -903,10 +905,29 @@ public MethodSymbol Retarget(MethodSymbol method, IEqualityComparer<MethodSymbol
                 var containingType = method.ContainingType;
                 var retargetedType = Retarget(containingType, RetargetOptions.RetargetPrimitiveTypesByName);
 
+                if (ReferenceEquals(retargetedType, containingType))
+                {
+                    return method;
+                }
+
+                if (!containingType.IsDefinition)
+                {
+                    Debug.Assert(!retargetedType.IsDefinition);
+
+                    var retargetedDefinition = Retarget(method.OriginalDefinition, retargetedMethodComparer);
+
+                    if (retargetedDefinition is null)
+                    {
+                        return null;
+                    }
+
+                    return retargetedDefinition.AsMember(retargetedType);
+                }
+
+                Debug.Assert(retargetedType.IsDefinition);
+
                 // NB: may return null if the method cannot be found in the retargeted type (e.g. removed in a subsequent version)
-                return ReferenceEquals(retargetedType, containingType) ?
-                           method :
-                           FindMethodInRetargetedType(method, retargetedType, retargetedMethodComparer);
+                return FindMethodInRetargetedType(method, retargetedType, retargetedMethodComparer);
             }
 
             public FieldSymbol Retarget(FieldSymbol field)
@@ -961,21 +982,26 @@ private MethodSymbol FindMethodInRetargetedType(MethodSymbol method, NamedTypeSy
 
             private class RetargetedTypeMethodFinder : RetargetingSymbolTranslator
             {
-                private RetargetedTypeMethodFinder(RetargetingModuleSymbol retargetingModule) :
+                private readonly NamedTypeSymbol _retargetedType;
+                private readonly MethodSymbol _toFind;
+
+                private RetargetedTypeMethodFinder(RetargetingModuleSymbol retargetingModule, NamedTypeSymbol retargetedType, MethodSymbol toFind) :
                     base(retargetingModule)
                 {
+                    _retargetedType = retargetedType;
+                    _toFind = toFind;
                 }
 
                 public static MethodSymbol Find(RetargetingSymbolTranslator translator, MethodSymbol method, NamedTypeSymbol retargetedType, IEqualityComparer<MethodSymbol> retargetedMethodComparer)
                 {
-                    if (!method.IsGenericMethod)
+                    if (!method.IsGenericMethod && !retargetedType.IsGenericType)
                     {
                         return FindWorker(translator, method, retargetedType, retargetedMethodComparer);
                     }
 
-                    // A generic method needs special handling because its signature is very likely
-                    // to refer to method's type parameters.
-                    var finder = new RetargetedTypeMethodFinder(translator._retargetingModule);
+                    // A generic method or a method in generic type needs special handling because its signature is very likely
+                    // to refer to method's or type's type parameters.
+                    var finder = new RetargetedTypeMethodFinder(translator._retargetingModule, retargetedType, method);
                     return FindWorker(finder, method, retargetedType, retargetedMethodComparer);
                 }
 
@@ -1013,6 +1039,7 @@ IEqualityComparer<MethodSymbol> retargetedMethodComparer
                         targetParamsBuilder.ToImmutableAndFree(),
                         method.RefKind,
                         method.IsInitOnly,
+                        method.IsStatic,
                         translator.Retarget(method.ReturnTypeWithAnnotations, RetargetOptions.RetargetPrimitiveTypesByTypeCode),
                         translator.RetargetModifiers(method.RefCustomModifiers, out modifiersHaveChanged_Ignored),
                         ImmutableArray<MethodSymbol>.Empty);
@@ -1034,16 +1061,31 @@ IEqualityComparer<MethodSymbol> retargetedMethodComparer
 
                 public override TypeParameterSymbol Retarget(TypeParameterSymbol typeParameter)
                 {
-                    if (ReferenceEquals(typeParameter.ContainingModule, this.UnderlyingModule))
+                    if (typeParameter.TypeParameterKind == TypeParameterKind.Method)
                     {
-                        return base.Retarget(typeParameter);
+                        Debug.Assert((object)typeParameter.ContainingSymbol == _toFind);
+
+                        // The method symbol we are building will be using IndexedTypeParameterSymbols as 
+                        // its type parameters, therefore, we should return them here as well.
+                        return IndexedTypeParameterSymbol.GetTypeParameter(typeParameter.Ordinal);
                     }
 
-                    Debug.Assert(typeParameter.TypeParameterKind == TypeParameterKind.Method);
+                    NamedTypeSymbol containingType = _toFind.ContainingType;
+                    NamedTypeSymbol retargetedContainingType = _retargetedType;
+
+                    do
+                    {
+                        if ((object)containingType == typeParameter.ContainingSymbol)
+                        {
+                            return retargetedContainingType.TypeParameters[typeParameter.Ordinal];
+                        }
+
+                        containingType = containingType.ContainingType;
+                        retargetedContainingType = retargetedContainingType.ContainingType;
+                    }
+                    while (containingType is object);
 
-                    // The method symbol we are building will be using IndexedTypeParameterSymbols as 
-                    // its type parameters, therefore, we should return them here as well.
-                    return IndexedTypeParameterSymbol.GetTypeParameter(typeParameter.Ordinal);
+                    throw ExceptionUtilities.Unreachable;
                 }
             }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyMethodSymbol.cs
index 5656f9ee1110a..59a09861eb1cf 100644
--- a/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyMethodSymbol.cs
@@ -26,6 +26,7 @@ internal sealed class SignatureOnlyMethodSymbol : MethodSymbol
         private readonly ImmutableArray<ParameterSymbol> _parameters;
         private readonly RefKind _refKind;
         private readonly bool _isInitOnly;
+        private readonly bool _isStatic;
         private readonly TypeWithAnnotations _returnType;
         private readonly ImmutableArray<CustomModifier> _refCustomModifiers;
         private readonly ImmutableArray<MethodSymbol> _explicitInterfaceImplementations;
@@ -39,6 +40,7 @@ public SignatureOnlyMethodSymbol(
             ImmutableArray<ParameterSymbol> parameters,
             RefKind refKind,
             bool isInitOnly,
+            bool isStatic,
             TypeWithAnnotations returnType,
             ImmutableArray<CustomModifier> refCustomModifiers,
             ImmutableArray<MethodSymbol> explicitInterfaceImplementations)
@@ -48,6 +50,7 @@ public SignatureOnlyMethodSymbol(
             _typeParameters = typeParameters;
             _refKind = refKind;
             _isInitOnly = isInitOnly;
+            _isStatic = isStatic;
             _returnType = returnType;
             _refCustomModifiers = refCustomModifiers;
             _parameters = parameters;
@@ -131,7 +134,7 @@ public SignatureOnlyMethodSymbol(
 
         public override Accessibility DeclaredAccessibility { get { throw ExceptionUtilities.Unreachable; } }
 
-        public override bool IsStatic { get { throw ExceptionUtilities.Unreachable; } }
+        public override bool IsStatic { get { return _isStatic; } }
 
         public override bool IsAsync { get { throw ExceptionUtilities.Unreachable; } }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ExplicitInterfaceHelpers.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ExplicitInterfaceHelpers.cs
index cb3611b172bdf..594b978d53f02 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/ExplicitInterfaceHelpers.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/ExplicitInterfaceHelpers.cs
@@ -109,41 +109,47 @@ public static string GetMemberNameWithoutInterfaceName(string fullName)
             return (idx > 0) ? fullName.Substring(idx + 1) : fullName; //don't consider leading dots
         }
 
+#nullable enable
         public static ImmutableArray<T> SubstituteExplicitInterfaceImplementations<T>(ImmutableArray<T> unsubstitutedExplicitInterfaceImplementations, TypeMap map) where T : Symbol
         {
             var builder = ArrayBuilder<T>.GetInstance();
             foreach (var unsubstitutedPropertyImplemented in unsubstitutedExplicitInterfaceImplementations)
             {
-                var unsubstitutedInterfaceType = unsubstitutedPropertyImplemented.ContainingType;
-                Debug.Assert((object)unsubstitutedInterfaceType != null);
-                var explicitInterfaceType = map.SubstituteNamedType(unsubstitutedInterfaceType);
-                Debug.Assert((object)explicitInterfaceType != null);
-                var name = unsubstitutedPropertyImplemented.Name; //should already be unqualified
-
-                T substitutedMemberImplemented = null;
-                foreach (var candidateMember in explicitInterfaceType.GetMembers(name))
+                builder.Add(SubstituteExplicitInterfaceImplementation(unsubstitutedPropertyImplemented, map));
+            }
+
+            return builder.ToImmutableAndFree();
+        }
+
+        public static T SubstituteExplicitInterfaceImplementation<T>(T unsubstitutedPropertyImplemented, TypeMap map) where T : Symbol
+        {
+            var unsubstitutedInterfaceType = unsubstitutedPropertyImplemented.ContainingType;
+            Debug.Assert((object)unsubstitutedInterfaceType != null);
+            var explicitInterfaceType = map.SubstituteNamedType(unsubstitutedInterfaceType);
+            Debug.Assert((object)explicitInterfaceType != null);
+            var name = unsubstitutedPropertyImplemented.Name; //should already be unqualified
+
+            foreach (var candidateMember in explicitInterfaceType.GetMembers(name))
+            {
+                if (candidateMember.OriginalDefinition == unsubstitutedPropertyImplemented.OriginalDefinition)
                 {
-                    if (candidateMember.OriginalDefinition == unsubstitutedPropertyImplemented.OriginalDefinition)
-                    {
-                        substitutedMemberImplemented = (T)candidateMember;
-                        break;
-                    }
+                    return (T)candidateMember;
                 }
-                Debug.Assert((object)substitutedMemberImplemented != null); //if it was an explicit implementation before the substitution, it should still be after
-                builder.Add(substitutedMemberImplemented);
             }
 
-            return builder.ToImmutableAndFree();
+            throw ExceptionUtilities.Unreachable;
         }
+#nullable disable
 
         internal static MethodSymbol FindExplicitlyImplementedMethod(
             this MethodSymbol implementingMethod,
+            bool isOperator,
             TypeSymbol explicitInterfaceType,
             string interfaceMethodName,
             ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifierSyntax,
             BindingDiagnosticBag diagnostics)
         {
-            return (MethodSymbol)FindExplicitlyImplementedMember(implementingMethod, explicitInterfaceType, interfaceMethodName, explicitInterfaceSpecifierSyntax, diagnostics);
+            return (MethodSymbol)FindExplicitlyImplementedMember(implementingMethod, isOperator, explicitInterfaceType, interfaceMethodName, explicitInterfaceSpecifierSyntax, diagnostics);
         }
 
         internal static PropertySymbol FindExplicitlyImplementedProperty(
@@ -153,7 +159,7 @@ internal static PropertySymbol FindExplicitlyImplementedProperty(
             ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifierSyntax,
             BindingDiagnosticBag diagnostics)
         {
-            return (PropertySymbol)FindExplicitlyImplementedMember(implementingProperty, explicitInterfaceType, interfacePropertyName, explicitInterfaceSpecifierSyntax, diagnostics);
+            return (PropertySymbol)FindExplicitlyImplementedMember(implementingProperty, isOperator: false, explicitInterfaceType, interfacePropertyName, explicitInterfaceSpecifierSyntax, diagnostics);
         }
 
         internal static EventSymbol FindExplicitlyImplementedEvent(
@@ -163,11 +169,12 @@ internal static EventSymbol FindExplicitlyImplementedEvent(
             ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifierSyntax,
             BindingDiagnosticBag diagnostics)
         {
-            return (EventSymbol)FindExplicitlyImplementedMember(implementingEvent, explicitInterfaceType, interfaceEventName, explicitInterfaceSpecifierSyntax, diagnostics);
+            return (EventSymbol)FindExplicitlyImplementedMember(implementingEvent, isOperator: false, explicitInterfaceType, interfaceEventName, explicitInterfaceSpecifierSyntax, diagnostics);
         }
 
         private static Symbol FindExplicitlyImplementedMember(
             Symbol implementingMember,
+            bool isOperator,
             TypeSymbol explicitInterfaceType,
             string interfaceMemberName,
             ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifierSyntax,
@@ -227,55 +234,64 @@ private static Symbol FindExplicitlyImplementedMember(
                 //do a lookup anyway
             }
 
-            // Do not look in itself
-            if (containingType == (object)explicitInterfaceNamedType.OriginalDefinition)
-            {
-                // An error will be reported elsewhere.
-                // Either the interface is not implemented, or it causes a cycle in the interface hierarchy.
-                return null;
-            }
-
-            var hasParamsParam = implementingMember.HasParamsParameter();
-
             // Setting this flag to true does not imply that an interface member has been successfully implemented.
             // It just indicates that a corresponding interface member has been found (there may still be errors).
             var foundMatchingMember = false;
 
             Symbol implementedMember = null;
 
-            foreach (Symbol interfaceMember in explicitInterfaceNamedType.GetMembers(interfaceMemberName))
+            if (!implementingMember.IsStatic || !containingType.IsInterface)
             {
-                // At this point, we know that explicitInterfaceNamedType is an interface.
-                // However, metadata interface members can be static - we ignore them, as does Dev10.
-                if (interfaceMember.Kind != implementingMember.Kind || !interfaceMember.IsImplementableInterfaceMember())
+                // Do not look in itself
+                if (containingType == (object)explicitInterfaceNamedType.OriginalDefinition)
                 {
-                    continue;
+                    // An error will be reported elsewhere.
+                    // Either the interface is not implemented, or it causes a cycle in the interface hierarchy.
+                    return null;
                 }
 
-                if (MemberSignatureComparer.ExplicitImplementationComparer.Equals(implementingMember, interfaceMember))
+                var hasParamsParam = implementingMember.HasParamsParameter();
+
+                foreach (Symbol interfaceMember in explicitInterfaceNamedType.GetMembers(interfaceMemberName))
                 {
-                    foundMatchingMember = true;
-                    // Cannot implement accessor directly unless
-                    // the accessor is from an indexed property.
-                    if (interfaceMember.IsAccessor() && !((MethodSymbol)interfaceMember).IsIndexedPropertyAccessor())
+                    // At this point, we know that explicitInterfaceNamedType is an interface.
+                    // However, metadata interface members can be static - we ignore them, as does Dev10.
+                    if (interfaceMember.Kind != implementingMember.Kind || !interfaceMember.IsImplementableInterfaceMember())
                     {
-                        diagnostics.Add(ErrorCode.ERR_ExplicitMethodImplAccessor, memberLocation, implementingMember, interfaceMember);
+                        continue;
                     }
-                    else
+
+                    if (interfaceMember is MethodSymbol interfaceMethod &&
+                        (interfaceMethod.MethodKind is MethodKind.UserDefinedOperator or MethodKind.Conversion) != isOperator)
                     {
-                        if (interfaceMember.MustCallMethodsDirectly())
+                        continue;
+                    }
+
+                    if (MemberSignatureComparer.ExplicitImplementationComparer.Equals(implementingMember, interfaceMember))
+                    {
+                        foundMatchingMember = true;
+                        // Cannot implement accessor directly unless
+                        // the accessor is from an indexed property.
+                        if (interfaceMember.IsAccessor() && !((MethodSymbol)interfaceMember).IsIndexedPropertyAccessor())
                         {
-                            diagnostics.Add(ErrorCode.ERR_BogusExplicitImpl, memberLocation, implementingMember, interfaceMember);
+                            diagnostics.Add(ErrorCode.ERR_ExplicitMethodImplAccessor, memberLocation, implementingMember, interfaceMember);
                         }
-                        else if (hasParamsParam && !interfaceMember.HasParamsParameter())
+                        else
                         {
-                            // Note: no error for !hasParamsParam && interfaceMethod.HasParamsParameter()
-                            // Still counts as an implementation.
-                            diagnostics.Add(ErrorCode.ERR_ExplicitImplParams, memberLocation, implementingMember, interfaceMember);
-                        }
+                            if (interfaceMember.MustCallMethodsDirectly())
+                            {
+                                diagnostics.Add(ErrorCode.ERR_BogusExplicitImpl, memberLocation, implementingMember, interfaceMember);
+                            }
+                            else if (hasParamsParam && !interfaceMember.HasParamsParameter())
+                            {
+                                // Note: no error for !hasParamsParam && interfaceMethod.HasParamsParameter()
+                                // Still counts as an implementation.
+                                diagnostics.Add(ErrorCode.ERR_ExplicitImplParams, memberLocation, implementingMember, interfaceMember);
+                            }
 
-                        implementedMember = interfaceMember;
-                        break;
+                            implementedMember = interfaceMember;
+                            break;
+                        }
                     }
                 }
             }
@@ -351,6 +367,11 @@ internal static void FindExplicitlyImplementedMemberVerification(
             // tried to implement the ambiguous interface implicitly, we would separately raise an error about
             // the implicit implementation methods differing by only ref/out.
             FindExplicitImplementationCollisions(implementingMember, implementedMember, diagnostics);
+
+            if (implementedMember.IsStatic && !implementingMember.ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)
+            {
+                diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, implementingMember.Locations[0]);
+            }
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/LambdaSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/LambdaSymbol.cs
index 5a19816808171..99bcd710cec2f 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/LambdaSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/LambdaSymbol.cs
@@ -49,8 +49,11 @@ public LambdaSymbol(
             _binder = binder;
             _containingSymbol = containingSymbol;
             _messageID = unboundLambda.Data.MessageID;
-            _refKind = refKind;
-            _returnType = !returnType.HasType ? TypeWithAnnotations.Create(ReturnTypeIsBeingInferred) : returnType;
+            if (!unboundLambda.HasExplicitReturnType(out _refKind, out _returnType))
+            {
+                _refKind = refKind;
+                _returnType = !returnType.HasType ? TypeWithAnnotations.Create(ReturnTypeIsBeingInferred) : returnType;
+            }
             _isSynthesized = unboundLambda.WasCompilerGenerated;
             _isAsync = unboundLambda.IsAsync;
             _isStatic = unboundLambda.IsStatic;
@@ -235,6 +238,8 @@ internal Location DiagnosticLocation
             }
         }
 
+        private bool HasExplicitReturnType => Syntax is ParenthesizedLambdaExpressionSyntax { ReturnType: not null };
+
         public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences
         {
             get
@@ -281,6 +286,12 @@ internal void GetDeclarationDiagnostics(BindingDiagnosticBag addTo)
             GetAttributes();
             GetReturnTypeAttributes();
 
+            AsyncMethodChecks(verifyReturnType: HasExplicitReturnType, DiagnosticLocation, _declarationDiagnostics);
+            if (!HasExplicitReturnType && this.HasAsyncMethodBuilderAttribute(out _))
+            {
+                addTo.Add(ErrorCode.ERR_BuilderAttributeDisallowed, DiagnosticLocation);
+            }
+
             addTo.AddRange(_declarationDiagnostics, allowMismatchInDependencyAccumulation: true);
         }
 
@@ -314,7 +325,7 @@ private ImmutableArray<ParameterSymbol> MakeParameters(
 
             for (int p = 0; p < unboundLambda.ParameterCount; ++p)
             {
-                // If there are no types given in the lambda then used the delegate type.
+                // If there are no types given in the lambda then use the delegate type.
                 // If the lambda is typed then the types probably match the delegate types;
                 // if they do not, use the lambda types for binding. Either way, if we 
                 // can, then we use the lambda types. (Whatever you do, do not use the names 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ModifierUtils.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ModifierUtils.cs
index 1d162213df4cd..f28cdf1356928 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/ModifierUtils.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/ModifierUtils.cs
@@ -39,6 +39,14 @@ internal static DeclarationModifiers CheckModifiers(
             out bool modifierErrors)
         {
             modifierErrors = false;
+            DeclarationModifiers reportStaticNotVirtualForModifiers = DeclarationModifiers.None;
+
+            if ((modifiers & allowedModifiers & DeclarationModifiers.Static) != 0)
+            {
+                reportStaticNotVirtualForModifiers = allowedModifiers & (DeclarationModifiers.Override | DeclarationModifiers.Virtual);
+                allowedModifiers &= ~reportStaticNotVirtualForModifiers;
+            }
+
             DeclarationModifiers errorModifiers = modifiers & ~allowedModifiers;
             DeclarationModifiers result = modifiers & allowedModifiers;
 
@@ -55,6 +63,16 @@ internal static DeclarationModifiers CheckModifiers(
                         ReportPartialError(errorLocation, diagnostics, modifierTokens);
                         break;
 
+                    case DeclarationModifiers.Override:
+                    case DeclarationModifiers.Virtual:
+                        if ((reportStaticNotVirtualForModifiers & oneError) == 0)
+                        {
+                            goto default;
+                        }
+
+                        diagnostics.Add(ErrorCode.ERR_StaticNotVirtual, errorLocation, ModifierUtils.ConvertSingleModifierToSyntaxText(oneError));
+                        break;
+
                     default:
                         diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, ConvertSingleModifierToSyntaxText(oneError));
                         break;
@@ -94,25 +112,76 @@ internal static void ReportDefaultInterfaceImplementationModifiers(
             Location errorLocation,
             BindingDiagnosticBag diagnostics)
         {
-            if (!hasBody && (modifiers & defaultInterfaceImplementationModifiers) != 0)
+            if ((modifiers & defaultInterfaceImplementationModifiers) != 0)
             {
                 LanguageVersion availableVersion = ((CSharpParseOptions)errorLocation.SourceTree.Options).LanguageVersion;
-                LanguageVersion requiredVersion = MessageID.IDS_DefaultInterfaceImplementation.RequiredVersion();
-                if (availableVersion < requiredVersion)
+                LanguageVersion requiredVersion;
+
+                if ((modifiers & defaultInterfaceImplementationModifiers & DeclarationModifiers.Static) != 0 &&
+                    (modifiers & defaultInterfaceImplementationModifiers & (DeclarationModifiers.Sealed | DeclarationModifiers.Abstract)) != 0)
                 {
-                    DeclarationModifiers errorModifiers = modifiers & defaultInterfaceImplementationModifiers;
-                    var requiredVersionArgument = new CSharpRequiredLanguageVersion(requiredVersion);
-                    var availableVersionArgument = availableVersion.ToDisplayString();
-                    while (errorModifiers != DeclarationModifiers.None)
+                    var reportModifiers = DeclarationModifiers.Sealed | DeclarationModifiers.Abstract;
+                    if ((modifiers & defaultInterfaceImplementationModifiers & (DeclarationModifiers.Sealed | DeclarationModifiers.Abstract)) == (DeclarationModifiers.Sealed | DeclarationModifiers.Abstract))
                     {
-                        DeclarationModifiers oneError = errorModifiers & ~(errorModifiers - 1);
-                        Debug.Assert(oneError != DeclarationModifiers.None);
-                        errorModifiers = errorModifiers & ~oneError;
-                        diagnostics.Add(ErrorCode.ERR_InvalidModifierForLanguageVersion, errorLocation,
-                                        ConvertSingleModifierToSyntaxText(oneError),
-                                        availableVersionArgument,
-                                        requiredVersionArgument);
+                        diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, ConvertSingleModifierToSyntaxText(DeclarationModifiers.Sealed));
+                        reportModifiers &= ~DeclarationModifiers.Sealed;
                     }
+
+                    requiredVersion = MessageID.IDS_FeatureStaticAbstractMembersInInterfaces.RequiredVersion();
+                    if (availableVersion < requiredVersion)
+                    {
+                        ReportUnsupportedModifiersForLanguageVersion(modifiers, reportModifiers, errorLocation, diagnostics, availableVersion, requiredVersion);
+                    }
+
+                    return; // below we will either ask for an earlier version of the language, or will not report anything
+                }
+
+                if (hasBody)
+                {
+                    if ((modifiers & defaultInterfaceImplementationModifiers & DeclarationModifiers.Static) != 0)
+                    {
+                        Binder.CheckFeatureAvailability(errorLocation.SourceTree, MessageID.IDS_DefaultInterfaceImplementation, diagnostics, errorLocation);
+                    }
+                }
+                else
+                {
+                    requiredVersion = MessageID.IDS_DefaultInterfaceImplementation.RequiredVersion();
+                    if (availableVersion < requiredVersion)
+                    {
+                        ReportUnsupportedModifiersForLanguageVersion(modifiers, defaultInterfaceImplementationModifiers, errorLocation, diagnostics, availableVersion, requiredVersion);
+                    }
+                }
+            }
+        }
+
+        internal static void ReportUnsupportedModifiersForLanguageVersion(DeclarationModifiers modifiers, DeclarationModifiers unsupportedModifiers, Location errorLocation, BindingDiagnosticBag diagnostics, LanguageVersion availableVersion, LanguageVersion requiredVersion)
+        {
+            DeclarationModifiers errorModifiers = modifiers & unsupportedModifiers;
+            var requiredVersionArgument = new CSharpRequiredLanguageVersion(requiredVersion);
+            var availableVersionArgument = availableVersion.ToDisplayString();
+            while (errorModifiers != DeclarationModifiers.None)
+            {
+                DeclarationModifiers oneError = errorModifiers & ~(errorModifiers - 1);
+                Debug.Assert(oneError != DeclarationModifiers.None);
+                errorModifiers = errorModifiers & ~oneError;
+                diagnostics.Add(ErrorCode.ERR_InvalidModifierForLanguageVersion, errorLocation,
+                                ConvertSingleModifierToSyntaxText(oneError),
+                                availableVersionArgument,
+                                requiredVersionArgument);
+            }
+        }
+
+        internal static void CheckFeatureAvailabilityForStaticAbstractMembersInInterfacesIfNeeded(DeclarationModifiers mods, bool isExplicitInterfaceImplementation, Location location, BindingDiagnosticBag diagnostics)
+        {
+            if (isExplicitInterfaceImplementation && (mods & DeclarationModifiers.Static) != 0)
+            {
+                Debug.Assert(location.SourceTree is not null);
+
+                LanguageVersion availableVersion = ((CSharpParseOptions)location.SourceTree.Options).LanguageVersion;
+                LanguageVersion requiredVersion = MessageID.IDS_FeatureStaticAbstractMembersInInterfaces.RequiredVersion();
+                if (availableVersion < requiredVersion)
+                {
+                    ModifierUtils.ReportUnsupportedModifiersForLanguageVersion(mods, DeclarationModifiers.Static, location, diagnostics, availableVersion, requiredVersion);
                 }
             }
         }
@@ -126,7 +195,11 @@ internal static DeclarationModifiers AdjustModifiersForAnInterfaceMember(Declara
                     mods |= DeclarationModifiers.Sealed;
                 }
             }
-            else if ((mods & (DeclarationModifiers.Static | DeclarationModifiers.Private | DeclarationModifiers.Partial | DeclarationModifiers.Virtual | DeclarationModifiers.Abstract)) == 0)
+            else if ((mods & DeclarationModifiers.Static) != 0)
+            {
+                mods &= ~DeclarationModifiers.Sealed;
+            }
+            else if ((mods & (DeclarationModifiers.Private | DeclarationModifiers.Partial | DeclarationModifiers.Virtual | DeclarationModifiers.Abstract)) == 0)
             {
                 Debug.Assert(!isExplicitInterfaceImplementation);
 
@@ -162,7 +235,7 @@ internal static DeclarationModifiers AdjustModifiersForAnInterfaceMember(Declara
             return mods;
         }
 
-        private static string ConvertSingleModifierToSyntaxText(DeclarationModifiers modifier)
+        internal static string ConvertSingleModifierToSyntaxText(DeclarationModifiers modifier)
         {
             switch (modifier)
             {
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/QuickAttributeChecker.cs b/src/Compilers/CSharp/Portable/Symbols/Source/QuickAttributeChecker.cs
index ddd2376eb8bcd..7d16f839c85f5 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/QuickAttributeChecker.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/QuickAttributeChecker.cs
@@ -48,6 +48,9 @@ private static QuickAttributeChecker CreatePredefinedQuickAttributeChecker()
             var result = new QuickAttributeChecker();
             result.AddName(AttributeDescription.TypeIdentifierAttribute.Name, QuickAttributes.TypeIdentifier);
             result.AddName(AttributeDescription.TypeForwardedToAttribute.Name, QuickAttributes.TypeForwardedTo);
+            result.AddName(AttributeDescription.AssemblyKeyNameAttribute.Name, QuickAttributes.AssemblyKeyName);
+            result.AddName(AttributeDescription.AssemblyKeyFileAttribute.Name, QuickAttributes.AssemblyKeyFile);
+            result.AddName(AttributeDescription.AssemblySignatureKeyAttribute.Name, QuickAttributes.AssemblySignatureKey);
 
 #if DEBUG
             result._sealed = true;
@@ -138,6 +141,9 @@ internal enum QuickAttributes : byte
     {
         None = 0,
         TypeIdentifier = 1 << 0,
-        TypeForwardedTo = 2 << 0
+        TypeForwardedTo = 1 << 1,
+        AssemblyKeyName = 1 << 2,
+        AssemblyKeyFile = 1 << 3,
+        AssemblySignatureKey = 1 << 4,
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs
index 2f742177e6587..a1435acbad92c 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs
@@ -204,19 +204,26 @@ internal override Symbol GetSpecialTypeMember(SpecialMember member)
             return _compilation.IsMemberMissing(member) ? null : base.GetSpecialTypeMember(member);
         }
 
-        private string GetWellKnownAttributeDataStringField(Func<CommonAssemblyWellKnownAttributeData, string> fieldGetter, string missingValue = null)
+#nullable enable
+        private string? GetWellKnownAttributeDataStringField(Func<CommonAssemblyWellKnownAttributeData, string> fieldGetter, string? missingValue = null, QuickAttributes? attributeMatchesOpt = null)
         {
-            string fieldValue = missingValue;
+            string? fieldValue = missingValue;
+
+            var data = attributeMatchesOpt is null
+                ? GetSourceDecodedWellKnownAttributeData()
+                : GetSourceDecodedWellKnownAttributeData(attributeMatchesOpt.Value);
 
-            var data = GetSourceDecodedWellKnownAttributeData();
             if (data != null)
             {
                 fieldValue = fieldGetter(data);
             }
 
-            if ((object)fieldValue == (object)missingValue)
+            if (fieldValue == (object?)missingValue)
             {
-                data = GetNetModuleDecodedWellKnownAttributeData();
+                data = (attributeMatchesOpt is null || _lazyNetModuleAttributesBag is not null)
+                    ? GetNetModuleDecodedWellKnownAttributeData()
+                    : GetLimitedNetModuleDecodedWellKnownAttributeData(attributeMatchesOpt.Value);
+
                 if (data != null)
                 {
                     fieldValue = fieldGetter(data);
@@ -225,6 +232,7 @@ private string GetWellKnownAttributeDataStringField(Func<CommonAssemblyWellKnown
 
             return fieldValue;
         }
+#nullable disable
 
         internal bool RuntimeCompatibilityWrapNonExceptionThrows
         {
@@ -331,7 +339,9 @@ private string AssemblyKeyContainerAttributeSetting
         {
             get
             {
-                return GetWellKnownAttributeDataStringField(data => data.AssemblyKeyContainerAttributeSetting, WellKnownAttributeData.StringMissingValue);
+                // We mitigate circularity problems by only actively loading attributes that pass a syntactic check
+                return GetWellKnownAttributeDataStringField(data => data.AssemblyKeyContainerAttributeSetting,
+                    WellKnownAttributeData.StringMissingValue, QuickAttributes.AssemblyKeyName);
             }
         }
 
@@ -339,7 +349,9 @@ private string AssemblyKeyFileAttributeSetting
         {
             get
             {
-                return GetWellKnownAttributeDataStringField(data => data.AssemblyKeyFileAttributeSetting, WellKnownAttributeData.StringMissingValue);
+                // We mitigate circularity problems by only actively loading attributes that pass a syntactic check
+                return GetWellKnownAttributeDataStringField(data => data.AssemblyKeyFileAttributeSetting,
+                    WellKnownAttributeData.StringMissingValue, QuickAttributes.AssemblyKeyFile);
             }
         }
 
@@ -355,7 +367,9 @@ public string SignatureKey
         {
             get
             {
-                return GetWellKnownAttributeDataStringField(data => data.AssemblySignatureKeyAttributeSetting);
+                // We mitigate circularity problems by only actively loading attributes that pass a syntactic check
+                return GetWellKnownAttributeDataStringField(data => data.AssemblySignatureKeyAttributeSetting,
+                    missingValue: null, QuickAttributes.AssemblySignatureKey);
             }
         }
 
@@ -456,12 +470,6 @@ public AssemblyFlags AssemblyFlags
 
         private StrongNameKeys ComputeStrongNameKeys()
         {
-            // TODO:
-            // In order to allow users to escape problems that we create with our provisional granting of IVT access,
-            // consider not binding the attributes if the command line options were specified, then later bind them
-            // and report warnings if both were used.
-            EnsureAttributesAreBound();
-
             // when both attributes and command-line options specified, cmd line wins.
             string keyFile = _compilation.Options.CryptoKeyFile;
 
@@ -1301,8 +1309,6 @@ private WellKnownAttributeData ValidateAttributeUsageAndDecodeWellKnownAttribute
             Debug.Assert(netModuleNames.Any());
             Debug.Assert(attributesFromNetModules.Length == netModuleNames.Length);
 
-            var tree = CSharpSyntaxTree.Dummy;
-
             int netModuleAttributesCount = attributesFromNetModules.Length;
             int sourceAttributesCount = this.GetSourceAttributesBag().Attributes.Length;
 
@@ -1432,22 +1438,93 @@ private void LoadAndValidateNetModuleAttributes(ref CustomAttributesBag<CSharpAt
                 }
 
                 diagnostics.Free();
-            }
 
-            Debug.Assert(lazyNetModuleAttributesBag.IsSealed);
+                Debug.Assert(lazyNetModuleAttributesBag.IsSealed);
+            }
         }
 
-        private void EnsureNetModuleAttributesAreBound()
+        private CommonAssemblyWellKnownAttributeData GetLimitedNetModuleDecodedWellKnownAttributeData(QuickAttributes attributeMatches)
         {
-            if (_lazyNetModuleAttributesBag == null)
+            Debug.Assert(attributeMatches is QuickAttributes.AssemblyKeyFile
+                or QuickAttributes.AssemblyKeyName
+                or QuickAttributes.AssemblySignatureKey);
+
+            if (_compilation.Options.OutputKind.IsNetModule())
             {
-                LoadAndValidateNetModuleAttributes(ref _lazyNetModuleAttributesBag);
+                return null;
+            }
+
+            ImmutableArray<string> netModuleNames;
+            ImmutableArray<CSharpAttributeData> attributesFromNetModules = GetNetModuleAttributes(out netModuleNames);
+
+            WellKnownAttributeData wellKnownData = null;
+
+            if (attributesFromNetModules.Any())
+            {
+                wellKnownData = limitedDecodeWellKnownAttributes(attributesFromNetModules, netModuleNames, attributeMatches);
+            }
+
+            return (CommonAssemblyWellKnownAttributeData)wellKnownData;
+
+            // Similar to ValidateAttributeUsageAndDecodeWellKnownAttributes, but doesn't load assembly-level attributes from source
+            // and only decodes 3 specific attributes.
+            WellKnownAttributeData limitedDecodeWellKnownAttributes(ImmutableArray<CSharpAttributeData> attributesFromNetModules,
+                ImmutableArray<string> netModuleNames, QuickAttributes attributeMatches)
+            {
+                Debug.Assert(attributesFromNetModules.Any());
+                Debug.Assert(netModuleNames.Any());
+                Debug.Assert(attributesFromNetModules.Length == netModuleNames.Length);
+
+                int netModuleAttributesCount = attributesFromNetModules.Length;
+
+                HashSet<CSharpAttributeData> uniqueAttributes = null;
+                CommonAssemblyWellKnownAttributeData result = null;
+
+                // Attributes from the second added module should override attributes from the first added module, etc.
+                // We don't reach here when the attribute was found in source already.
+                for (int i = netModuleAttributesCount - 1; i >= 0; i--)
+                {
+                    CSharpAttributeData attribute = attributesFromNetModules[i];
+                    if (!attribute.HasErrors && ValidateAttributeUsageForNetModuleAttribute(attribute, netModuleNames[i], BindingDiagnosticBag.Discarded, ref uniqueAttributes))
+                    {
+                        limitedDecodeWellKnownAttribute(attribute, attributeMatches, ref result);
+                    }
+                }
+
+                WellKnownAttributeData.Seal(result);
+                return result;
+            }
+
+            // Similar to DecodeWellKnownAttribute but only handles 3 specific attributes and ignores diagnostics.
+            void limitedDecodeWellKnownAttribute(CSharpAttributeData attribute, QuickAttributes attributeMatches, ref CommonAssemblyWellKnownAttributeData result)
+            {
+                if (attributeMatches is QuickAttributes.AssemblySignatureKey &&
+                    attribute.IsTargetAttribute(this, AttributeDescription.AssemblySignatureKeyAttribute))
+                {
+                    result ??= new CommonAssemblyWellKnownAttributeData();
+                    result.AssemblySignatureKeyAttributeSetting = (string)attribute.CommonConstructorArguments[0].ValueInternal;
+                }
+                else if (attributeMatches is QuickAttributes.AssemblyKeyFile &&
+                    attribute.IsTargetAttribute(this, AttributeDescription.AssemblyKeyFileAttribute))
+                {
+                    result ??= new CommonAssemblyWellKnownAttributeData();
+                    result.AssemblyKeyFileAttributeSetting = (string)attribute.CommonConstructorArguments[0].ValueInternal;
+                }
+                else if (attributeMatches is QuickAttributes.AssemblyKeyName &&
+                    attribute.IsTargetAttribute(this, AttributeDescription.AssemblyKeyNameAttribute))
+                {
+                    result ??= new CommonAssemblyWellKnownAttributeData();
+                    result.AssemblyKeyContainerAttributeSetting = (string)attribute.CommonConstructorArguments[0].ValueInternal;
+                }
             }
         }
 
         private CustomAttributesBag<CSharpAttributeData> GetNetModuleAttributesBag()
         {
-            EnsureNetModuleAttributesAreBound();
+            if (_lazyNetModuleAttributesBag == null)
+            {
+                LoadAndValidateNetModuleAttributes(ref _lazyNetModuleAttributesBag);
+            }
             return _lazyNetModuleAttributesBag;
         }
 
@@ -1563,6 +1640,52 @@ internal CommonAssemblyWellKnownAttributeData GetSourceDecodedWellKnownAttribute
             return (CommonAssemblyWellKnownAttributeData)attributesBag.DecodedWellKnownAttributeData;
         }
 
+#nullable enable
+        /// <remarks>
+        /// This implements the same logic as <see cref="GetSourceDecodedWellKnownAttributeData()"/>
+        /// but loading a smaller set of attributes if possible, to reduce circularity.
+        /// </remarks>
+        private CommonAssemblyWellKnownAttributeData? GetSourceDecodedWellKnownAttributeData(QuickAttributes attribute)
+        {
+            CustomAttributesBag<CSharpAttributeData>? attributesBag = _lazySourceAttributesBag;
+            if (attributesBag?.IsDecodedWellKnownAttributeDataComputed == true)
+            {
+                return (CommonAssemblyWellKnownAttributeData)attributesBag.DecodedWellKnownAttributeData;
+            }
+
+            attributesBag = null;
+            Func<AttributeSyntax, bool> attributeMatches = attribute switch
+            {
+                QuickAttributes.AssemblySignatureKey => isPossibleAssemblySignatureKeyAttribute,
+                QuickAttributes.AssemblyKeyName => isPossibleAssemblyKeyNameAttribute,
+                QuickAttributes.AssemblyKeyFile => isPossibleAssemblyKeyFileAttribute,
+                _ => throw ExceptionUtilities.UnexpectedValue(attribute)
+            };
+
+            LoadAndValidateAttributes(OneOrMany.Create(GetAttributeDeclarations()), ref attributesBag, attributeMatchesOpt: attributeMatches);
+
+            return (CommonAssemblyWellKnownAttributeData?)attributesBag?.DecodedWellKnownAttributeData;
+
+            bool isPossibleAssemblySignatureKeyAttribute(AttributeSyntax node)
+            {
+                QuickAttributeChecker checker = this.DeclaringCompilation.GetBinderFactory(node.SyntaxTree).GetBinder(node).QuickAttributeChecker;
+                return checker.IsPossibleMatch(node, QuickAttributes.AssemblySignatureKey);
+            }
+
+            bool isPossibleAssemblyKeyNameAttribute(AttributeSyntax node)
+            {
+                QuickAttributeChecker checker = this.DeclaringCompilation.GetBinderFactory(node.SyntaxTree).GetBinder(node).QuickAttributeChecker;
+                return checker.IsPossibleMatch(node, QuickAttributes.AssemblyKeyName);
+            }
+
+            bool isPossibleAssemblyKeyFileAttribute(AttributeSyntax node)
+            {
+                QuickAttributeChecker checker = this.DeclaringCompilation.GetBinderFactory(node.SyntaxTree).GetBinder(node).QuickAttributeChecker;
+                return checker.IsPossibleMatch(node, QuickAttributes.AssemblyKeyFile);
+            }
+        }
+#nullable disable
+
         /// <summary>
         /// This only forces binding of attributes that look like they may be forwarded types attributes (syntactically).
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceDelegateMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceDelegateMethodSymbol.cs
index b4eab31db8f74..d1282fe90152f 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceDelegateMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceDelegateMethodSymbol.cs
@@ -126,7 +126,8 @@ public sealed override ImmutableArray<ParameterSymbol> Parameters
         {
             get
             {
-                return _parameters;
+                Debug.Assert(!_parameters.IsDefault, $"Expected {nameof(InitializeParameters)} prior to accessing this property.");
+                return _parameters.NullToEmpty();
             }
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceEventAccessorSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceEventAccessorSymbol.cs
index a58e26f6b3bcc..03079cdc7b9b4 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceEventAccessorSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceEventAccessorSymbol.cs
@@ -58,7 +58,7 @@ public SourceEventAccessorSymbol(
                 returnsVoid: false, // until we learn otherwise (in LazyMethodChecks).
                 isExtensionMethod: false,
                 isNullableAnalysisEnabled: isNullableAnalysisEnabled,
-                isMetadataVirtualIgnoringModifiers: @event.IsExplicitInterfaceImplementation);
+                isMetadataVirtualIgnoringModifiers: @event.IsExplicitInterfaceImplementation && (@event.Modifiers & DeclarationModifiers.Static) == 0);
 
             _name = GetOverriddenAccessorName(@event, isAdder) ?? name;
         }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceEventSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceEventSymbol.cs
index 938424624c05f..87b77df7f5c2c 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceEventSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceEventSymbol.cs
@@ -14,6 +14,7 @@
 using System.Collections.Generic;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Emit;
+using System.Linq;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -468,10 +469,18 @@ private DeclarationModifiers MakeModifiers(SyntaxTokenList modifiers, bool expli
                                                                DeclarationModifiers.AccessibilityMask;
                 }
             }
-            else if (isInterface)
+            else
             {
                 Debug.Assert(explicitInterfaceImplementation);
-                allowedModifiers |= DeclarationModifiers.Abstract;
+
+                if (isInterface)
+                {
+                    allowedModifiers |= DeclarationModifiers.Abstract;
+                }
+                else
+                {
+                    allowedModifiers |= DeclarationModifiers.Static;
+                }
             }
 
             if (this.ContainingType.IsStructType())
@@ -486,6 +495,8 @@ private DeclarationModifiers MakeModifiers(SyntaxTokenList modifiers, bool expli
 
             var mods = ModifierUtils.MakeAndCheckNontypeMemberModifiers(modifiers, defaultAccess, allowedModifiers, location, diagnostics, out modifierErrors);
 
+            ModifierUtils.CheckFeatureAvailabilityForStaticAbstractMembersInInterfacesIfNeeded(mods, explicitInterfaceImplementation, location, diagnostics);
+
             this.CheckUnsafeModifier(mods, diagnostics);
 
             ModifierUtils.ReportDefaultInterfaceImplementationModifiers(!isFieldLike, mods,
@@ -504,6 +515,8 @@ private DeclarationModifiers MakeModifiers(SyntaxTokenList modifiers, bool expli
 
         protected void CheckModifiersAndType(BindingDiagnosticBag diagnostics)
         {
+            Debug.Assert(!IsStatic || (!IsVirtual && !IsOverride)); // Otherwise 'virtual' and 'override' should have been reported and cleared earlier.
+
             Location location = this.Locations[0];
             var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);
             bool isExplicitInterfaceImplementationInInterface = ContainingType.IsInterface && IsExplicitInterfaceImplementation;
@@ -512,10 +525,10 @@ protected void CheckModifiersAndType(BindingDiagnosticBag diagnostics)
             {
                 diagnostics.Add(ErrorCode.ERR_VirtualPrivate, location, this);
             }
-            else if (IsStatic && (IsOverride || IsVirtual || IsAbstract))
+            else if (IsStatic && IsAbstract && !ContainingType.IsInterface)
             {
-                // A static member '{0}' cannot be marked as override, virtual, or abstract
-                diagnostics.Add(ErrorCode.ERR_StaticNotVirtual, location, this);
+                // A static member '{0}' cannot be marked as 'abstract'
+                diagnostics.Add(ErrorCode.ERR_StaticNotVirtual, location, ModifierUtils.ConvertSingleModifierToSyntaxText(DeclarationModifiers.Abstract));
             }
             else if (IsReadOnly && IsStatic)
             {
@@ -746,6 +759,22 @@ internal override void AfterAddingTypeMembersChecks(ConversionsBase conversions,
             {
                 compilation.EnsureNullableAttributeExists(diagnostics, location, modifyCompilation: true);
             }
+
+            EventSymbol? explicitlyImplementedEvent = ExplicitInterfaceImplementations.FirstOrDefault();
+
+            if (explicitlyImplementedEvent is object)
+            {
+                CheckExplicitImplementationAccessor(AddMethod, explicitlyImplementedEvent.AddMethod, explicitlyImplementedEvent, diagnostics);
+                CheckExplicitImplementationAccessor(RemoveMethod, explicitlyImplementedEvent.RemoveMethod, explicitlyImplementedEvent, diagnostics);
+            }
+        }
+
+        private void CheckExplicitImplementationAccessor(MethodSymbol? thisAccessor, MethodSymbol? otherAccessor, EventSymbol explicitlyImplementedEvent, BindingDiagnosticBag diagnostics)
+        {
+            if (!otherAccessor.IsImplementable() && thisAccessor is object)
+            {
+                diagnostics.Add(ErrorCode.ERR_ExplicitPropertyAddingAccessor, thisAccessor.Locations[0], thisAccessor, explicitlyImplementedEvent);
+            }
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceFieldLikeEventSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceFieldLikeEventSymbol.cs
index b0e5c20b6900c..09ad70771b5ac 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceFieldLikeEventSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceFieldLikeEventSymbol.cs
@@ -93,7 +93,14 @@ internal SourceFieldLikeEventSymbol(SourceMemberContainerTypeSymbol containingTy
 
             if (inInterfaceType)
             {
-                if (this.IsExtern || this.IsStatic)
+                if (IsAbstract && IsStatic)
+                {
+                    if (!ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)
+                    {
+                        diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, this.Locations[0]);
+                    }
+                }
+                else if (this.IsExtern || this.IsStatic)
                 {
                     if (!ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)
                     {
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
index b96c538a7cbe0..7cf65647d90a8 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
@@ -166,7 +166,7 @@ public bool SetNullableContext(byte? value)
         private static readonly Dictionary<string, ImmutableArray<NamedTypeSymbol>> s_emptyTypeMembers = new Dictionary<string, ImmutableArray<NamedTypeSymbol>>(EmptyComparer.Instance);
         private Dictionary<string, ImmutableArray<NamedTypeSymbol>>? _lazyTypeMembers;
         private ImmutableArray<Symbol> _lazyMembersFlattened;
-        private ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> _lazySynthesizedExplicitImplementations;
+        private SynthesizedExplicitImplementations? _lazySynthesizedExplicitImplementations;
         private int _lazyKnownCircularStruct;
         private LexicalSortKey _lazyLexicalSortKey = LexicalSortKey.NotInitialized;
 
@@ -3371,10 +3371,13 @@ private static void CheckInterfaceMember(Symbol member, BindingDiagnosticBag dia
                             diagnostics.Add(ErrorCode.ERR_InterfacesCantContainConstructors, member.Locations[0]);
                             break;
                         case MethodKind.Conversion:
-                            diagnostics.Add(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, member.Locations[0]);
+                            if (!meth.IsAbstract)
+                            {
+                                diagnostics.Add(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, member.Locations[0]);
+                            }
                             break;
                         case MethodKind.UserDefinedOperator:
-                            if (meth.Name == WellKnownMemberNames.EqualityOperatorName || meth.Name == WellKnownMemberNames.InequalityOperatorName)
+                            if (!meth.IsAbstract && (meth.Name == WellKnownMemberNames.EqualityOperatorName || meth.Name == WellKnownMemberNames.InequalityOperatorName))
                             {
                                 diagnostics.Add(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, member.Locations[0]);
                             }
@@ -3573,6 +3576,7 @@ void addDeconstruct(SynthesizedRecordConstructor ctor, ImmutableArray<Symbol> po
                                                                                                                               )),
                     RefKind.None,
                     isInitOnly: false,
+                    isStatic: false,
                     TypeWithAnnotations.Create(compilation.GetSpecialType(SpecialType.System_Void)),
                     ImmutableArray<CustomModifier>.Empty,
                     ImmutableArray<MethodSymbol>.Empty);
@@ -3619,6 +3623,7 @@ void addCopyCtor(bool primaryAndCopyCtorAmbiguity)
                                                                 )),
                     RefKind.None,
                     isInitOnly: false,
+                    isStatic: false,
                     TypeWithAnnotations.Create(compilation.GetSpecialType(SpecialType.System_Void)),
                     ImmutableArray<CustomModifier>.Empty,
                     ImmutableArray<MethodSymbol>.Empty);
@@ -3665,6 +3670,7 @@ MethodSymbol addPrintMembersMethod()
                         RefKind.None)),
                     RefKind.None,
                     isInitOnly: false,
+                    isStatic: false,
                     returnType: TypeWithAnnotations.Create(compilation.GetSpecialType(SpecialType.System_Boolean)),
                     refCustomModifiers: ImmutableArray<CustomModifier>.Empty,
                     explicitInterfaceImplementations: ImmutableArray<MethodSymbol>.Empty);
@@ -3719,6 +3725,7 @@ void addToStringMethod(MethodSymbol printMethod)
                     ImmutableArray<ParameterSymbol>.Empty,
                     RefKind.None,
                     isInitOnly: false,
+                    isStatic: false,
                     returnType: TypeWithAnnotations.Create(compilation.GetSpecialType(SpecialType.System_String)),
                     refCustomModifiers: ImmutableArray<CustomModifier>.Empty,
                     explicitInterfaceImplementations: ImmutableArray<MethodSymbol>.Empty);
@@ -3887,6 +3894,7 @@ MethodSymbol addGetHashCode(PropertySymbol? equalityContract)
                     ImmutableArray<ParameterSymbol>.Empty,
                     RefKind.None,
                     isInitOnly: false,
+                    isStatic: false,
                     TypeWithAnnotations.Create(compilation.GetSpecialType(SpecialType.System_Int32)),
                     ImmutableArray<CustomModifier>.Empty,
                     ImmutableArray<MethodSymbol>.Empty);
@@ -3984,6 +3992,7 @@ MethodSymbol addThisEquals(PropertySymbol? equalityContract)
                                                                 )),
                     RefKind.None,
                     isInitOnly: false,
+                    isStatic: false,
                     TypeWithAnnotations.Create(compilation.GetSpecialType(SpecialType.System_Boolean)),
                     ImmutableArray<CustomModifier>.Empty,
                     ImmutableArray<MethodSymbol>.Empty);
@@ -4399,7 +4408,7 @@ private void AddNonTypeMembers(
                             }
 
                             var method = SourceUserDefinedConversionSymbol.CreateUserDefinedConversionSymbol(
-                                this, conversionOperatorSyntax, compilation.IsNullableAnalysisEnabledIn(conversionOperatorSyntax), diagnostics);
+                                this, bodyBinder, conversionOperatorSyntax, compilation.IsNullableAnalysisEnabledIn(conversionOperatorSyntax), diagnostics);
                             builder.NonTypeMembers.Add(method);
                         }
                         break;
@@ -4414,7 +4423,7 @@ private void AddNonTypeMembers(
                             }
 
                             var method = SourceUserDefinedOperatorSymbol.CreateUserDefinedOperatorSymbol(
-                                this, operatorSyntax, compilation.IsNullableAnalysisEnabledIn(operatorSyntax), diagnostics);
+                                this, bodyBinder, operatorSyntax, compilation.IsNullableAnalysisEnabledIn(operatorSyntax), diagnostics);
                             builder.NonTypeMembers.Add(method);
                         }
                         break;
@@ -4634,5 +4643,34 @@ public sealed override NamedTypeSymbol ConstructedFrom
         {
             get { return this; }
         }
+
+        internal class SynthesizedExplicitImplementations
+        {
+            public static readonly SynthesizedExplicitImplementations Empty = new SynthesizedExplicitImplementations(ImmutableArray<SynthesizedExplicitImplementationForwardingMethod>.Empty,
+                                                                                                                     ImmutableArray<(MethodSymbol Body, MethodSymbol Implemented)>.Empty);
+
+            public readonly ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> ForwardingMethods;
+            public readonly ImmutableArray<(MethodSymbol Body, MethodSymbol Implemented)> MethodImpls;
+
+            private SynthesizedExplicitImplementations(
+                ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> forwardingMethods,
+                ImmutableArray<(MethodSymbol Body, MethodSymbol Implemented)> methodImpls)
+            {
+                ForwardingMethods = forwardingMethods.NullToEmpty();
+                MethodImpls = methodImpls.NullToEmpty();
+            }
+
+            internal static SynthesizedExplicitImplementations Create(
+                ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> forwardingMethods,
+                ImmutableArray<(MethodSymbol Body, MethodSymbol Implemented)> methodImpls)
+            {
+                if (forwardingMethods.IsDefaultOrEmpty && methodImpls.IsDefaultOrEmpty)
+                {
+                    return Empty;
+                }
+
+                return new SynthesizedExplicitImplementations(forwardingMethods, methodImpls);
+            }
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol_ImplementationChecks.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol_ImplementationChecks.cs
index 72ead776605bc..dbad9f95ff24b 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol_ImplementationChecks.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol_ImplementationChecks.cs
@@ -26,10 +26,10 @@ internal partial class SourceMemberContainerTypeSymbol
         /// some interface methods.  They don't go in the symbol table, but if we are emitting, then we should
         /// generate code for them.
         /// </summary>
-        internal ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> GetSynthesizedExplicitImplementations(
+        internal SynthesizedExplicitImplementations GetSynthesizedExplicitImplementations(
             CancellationToken cancellationToken)
         {
-            if (_lazySynthesizedExplicitImplementations.IsDefault)
+            if (_lazySynthesizedExplicitImplementations is null)
             {
                 var diagnostics = BindingDiagnosticBag.GetInstance();
                 try
@@ -49,10 +49,10 @@ internal ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> GetSy
                         this.CheckInterfaceVarianceSafety(diagnostics);
                     }
 
-                    if (ImmutableInterlocked.InterlockedCompareExchange(
+                    if (Interlocked.CompareExchange(
                             ref _lazySynthesizedExplicitImplementations,
                             ComputeInterfaceImplementations(diagnostics, cancellationToken),
-                            default(ImmutableArray<SynthesizedExplicitImplementationForwardingMethod>)).IsDefault)
+                            null) is null)
                     {
                         // Do not cancel from this point on.  We've assigned the member, so we must add
                         // the diagnostics.
@@ -70,6 +70,21 @@ internal ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> GetSy
             return _lazySynthesizedExplicitImplementations;
         }
 
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            SynthesizedExplicitImplementations synthesizedImplementations = GetSynthesizedExplicitImplementations(cancellationToken: default);
+
+            foreach (var methodImpl in synthesizedImplementations.MethodImpls)
+            {
+                yield return methodImpl;
+            }
+
+            foreach (var forwardingMethod in synthesizedImplementations.ForwardingMethods)
+            {
+                yield return (forwardingMethod.ImplementingMethod, forwardingMethod.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
         private void CheckAbstractClassImplementations(BindingDiagnosticBag diagnostics)
         {
             NamedTypeSymbol baseType = this.BaseTypeNoUseSiteDiagnostics;
@@ -92,11 +107,12 @@ private void CheckAbstractClassImplementations(BindingDiagnosticBag diagnostics)
             }
         }
 
-        private ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> ComputeInterfaceImplementations(
+        private SynthesizedExplicitImplementations ComputeInterfaceImplementations(
             BindingDiagnosticBag diagnostics,
             CancellationToken cancellationToken)
         {
-            var synthesizedImplementations = ArrayBuilder<SynthesizedExplicitImplementationForwardingMethod>.GetInstance();
+            var forwardingMethods = ArrayBuilder<SynthesizedExplicitImplementationForwardingMethod>.GetInstance();
+            var methodImpls = ArrayBuilder<(MethodSymbol Body, MethodSymbol Implemented)>.GetInstance();
 
             // NOTE: We can't iterator over this collection directly, since it is not ordered.  Instead we
             // iterate over AllInterfaces and filter out the interfaces that are not in this set.  This is
@@ -115,7 +131,7 @@ private ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> Comput
 
                 HasBaseTypeDeclaringInterfaceResult? hasBaseClassDeclaringInterface = null;
 
-                foreach (var interfaceMember in @interface.GetMembersUnordered())
+                foreach (var interfaceMember in @interface.GetMembers())
                 {
                     cancellationToken.ThrowIfCancellationRequested();
 
@@ -164,9 +180,9 @@ private ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> Comput
 
                     bool wasImplementingMemberFound = (object)implementingMember != null;
 
-                    if ((object)synthesizedImplementation != null)
+                    if (synthesizedImplementation.ForwardingMethod is SynthesizedExplicitImplementationForwardingMethod forwardingMethod)
                     {
-                        if (synthesizedImplementation.IsVararg)
+                        if (forwardingMethod.IsVararg)
                         {
                             diagnostics.Add(
                                 ErrorCode.ERR_InterfaceImplementedImplicitlyByVariadic,
@@ -174,10 +190,16 @@ private ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> Comput
                         }
                         else
                         {
-                            synthesizedImplementations.Add(synthesizedImplementation);
+                            forwardingMethods.Add(forwardingMethod);
                         }
                     }
 
+                    if (synthesizedImplementation.MethodImpl is { } methodImpl)
+                    {
+                        Debug.Assert(methodImpl is { Body: not null, Implemented: not null });
+                        methodImpls.Add(methodImpl);
+                    }
+
                     if (wasImplementingMemberFound && interfaceMemberKind == SymbolKind.Event)
                     {
                         // NOTE: unlike dev11, we're including a related location for the implementing type, because
@@ -295,7 +317,7 @@ private ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> Comput
                                 // a synthesized implementation is needed that invokes the base method.
                                 // We can do so only if there are no use-site errors.
 
-                                if ((object)synthesizedImplementation != null || TypeSymbol.Equals(implementingMember.ContainingType, this, TypeCompareKind.ConsiderEverything2))
+                                if (synthesizedImplementation.ForwardingMethod is not null || TypeSymbol.Equals(implementingMember.ContainingType, this, TypeCompareKind.ConsiderEverything2))
                                 {
                                     UseSiteInfo<AssemblySymbol> useSiteInfo = interfaceMember.GetUseSiteInfo();
                                     // Don't report a use site error with a location in another compilation.  For example,
@@ -314,7 +336,7 @@ private ImmutableArray<SynthesizedExplicitImplementationForwardingMethod> Comput
                 }
             }
 
-            return synthesizedImplementations.ToImmutableAndFree();
+            return SynthesizedExplicitImplementations.Create(forwardingMethods.ToImmutableAndFree(), methodImpls.ToImmutableAndFree());
         }
 
         protected abstract Location GetCorrespondingBaseListLocation(NamedTypeSymbol @base);
@@ -1549,8 +1571,6 @@ private void CheckInterfaceUnification(BindingDiagnosticBag diagnostics)
             }
         }
 
-#nullable disable
-
         /// <summary>
         /// Though there is a method that C# considers to be an implementation of the interface method, that
         /// method may not be considered an implementation by the CLR.  In particular, implicit implementation
@@ -1561,23 +1581,18 @@ private void CheckInterfaceUnification(BindingDiagnosticBag diagnostics)
         /// </summary>
         /// <param name="implementingMemberAndDiagnostics">Returned from FindImplementationForInterfaceMemberWithDiagnostics.</param>
         /// <param name="interfaceMember">The interface method or property that is being implemented.</param>
-        /// <returns>Synthesized implementation or null if not needed.</returns>
-        private SynthesizedExplicitImplementationForwardingMethod SynthesizeInterfaceMemberImplementation(SymbolAndDiagnostics implementingMemberAndDiagnostics, Symbol interfaceMember)
+        /// <returns>
+        /// A synthesized forwarding method for the implementation, or information about MethodImpl entry that should be emitted,
+        /// or default if neither needed.
+        /// </returns>
+        private (SynthesizedExplicitImplementationForwardingMethod? ForwardingMethod, (MethodSymbol Body, MethodSymbol Implemented)? MethodImpl)
+            SynthesizeInterfaceMemberImplementation(SymbolAndDiagnostics implementingMemberAndDiagnostics, Symbol interfaceMember)
         {
-            if (interfaceMember.DeclaredAccessibility != Accessibility.Public)
-            {
-                // Non-public interface members cannot be implemented implicitly,
-                // appropriate errors are reported elsewhere. Let's not synthesize
-                // forwarding methods, or modify metadata virtualness of the
-                // implementing methods.
-                return null;
-            }
-
             foreach (Diagnostic diagnostic in implementingMemberAndDiagnostics.Diagnostics.Diagnostics)
             {
-                if (diagnostic.Severity == DiagnosticSeverity.Error)
+                if (diagnostic.Severity == DiagnosticSeverity.Error && diagnostic.Code is not (int)ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember)
                 {
-                    return null;
+                    return default;
                 }
             }
 
@@ -1586,62 +1601,71 @@ private SynthesizedExplicitImplementationForwardingMethod SynthesizeInterfaceMem
             //don't worry about properties or events - we'll catch them through their accessors
             if ((object)implementingMember == null || implementingMember.Kind != SymbolKind.Method)
             {
-                return null;
+                return default;
             }
 
             MethodSymbol interfaceMethod = (MethodSymbol)interfaceMember;
             MethodSymbol implementingMethod = (MethodSymbol)implementingMember;
 
-            // Interface properties/events with non-public accessors cannot be implemented implicitly,
-            // appropriate errors are reported elsewhere. Let's not synthesize
-            // forwarding methods, or modify metadata virtualness of the
-            // implementing accessors, even for public ones.
-            if (interfaceMethod.AssociatedSymbol?.IsEventOrPropertyWithImplementableNonPublicAccessor() == true)
-            {
-                return null;
-            }
-
             //explicit implementations are always respected by the CLR
             if (implementingMethod.ExplicitInterfaceImplementations.Contains(interfaceMethod, ExplicitInterfaceImplementationTargetMemberEqualityComparer.Instance))
             {
-                return null;
+                return default;
             }
 
-            MethodSymbol implementingMethodOriginalDefinition = implementingMethod.OriginalDefinition;
+            if (!interfaceMethod.IsStatic)
+            {
+                MethodSymbol implementingMethodOriginalDefinition = implementingMethod.OriginalDefinition;
 
-            bool needSynthesizedImplementation = true;
+                bool needSynthesizedImplementation = true;
 
-            // If the implementing method is from a source file in the same module and the
-            // override is correct from the runtime's perspective (esp the custom modifiers
-            // match), then we can just twiddle the metadata virtual bit.  Otherwise, we need
-            // to create an explicit implementation that delegates to the real implementation.
-            if (MemberSignatureComparer.RuntimeImplicitImplementationComparer.Equals(implementingMethod, interfaceMethod) &&
-                IsOverrideOfPossibleImplementationUnderRuntimeRules(implementingMethod, @interfaceMethod.ContainingType))
-            {
-                if (ReferenceEquals(this.ContainingModule, implementingMethodOriginalDefinition.ContainingModule))
+                // If the implementing method is from a source file in the same module and the
+                // override is correct from the runtime's perspective (esp the custom modifiers
+                // match), then we can just twiddle the metadata virtual bit.  Otherwise, we need
+                // to create an explicit implementation that delegates to the real implementation.
+                if (MemberSignatureComparer.RuntimeImplicitImplementationComparer.Equals(implementingMethod, interfaceMethod) &&
+                    IsOverrideOfPossibleImplementationUnderRuntimeRules(implementingMethod, @interfaceMethod.ContainingType))
                 {
-                    SourceMemberMethodSymbol sourceImplementMethodOriginalDefinition = implementingMethodOriginalDefinition as SourceMemberMethodSymbol;
-                    if ((object)sourceImplementMethodOriginalDefinition != null)
+                    if (ReferenceEquals(this.ContainingModule, implementingMethodOriginalDefinition.ContainingModule))
+                    {
+                        if (implementingMethodOriginalDefinition is SourceMemberMethodSymbol sourceImplementMethodOriginalDefinition)
+                        {
+                            sourceImplementMethodOriginalDefinition.EnsureMetadataVirtual();
+                            needSynthesizedImplementation = false;
+                        }
+                    }
+                    else if (implementingMethod.IsMetadataVirtual(ignoreInterfaceImplementationChanges: true))
                     {
-                        sourceImplementMethodOriginalDefinition.EnsureMetadataVirtual();
+                        // If the signatures match and the implementation method is definitely virtual, then we're set.
                         needSynthesizedImplementation = false;
                     }
                 }
-                else if (implementingMethod.IsMetadataVirtual(ignoreInterfaceImplementationChanges: true))
+
+                if (!needSynthesizedImplementation)
                 {
-                    // If the signatures match and the implementation method is definitely virtual, then we're set.
-                    needSynthesizedImplementation = false;
+                    return default;
                 }
             }
-
-            if (!needSynthesizedImplementation)
+            else
             {
-                return null;
+                if (implementingMethod.ContainingType != (object)this)
+                {
+                    if (implementingMethod.Equals(this.BaseTypeNoUseSiteDiagnostics?.FindImplementationForInterfaceMemberInNonInterfaceWithDiagnostics(interfaceMethod).Symbol, TypeCompareKind.CLRSignatureCompareOptions))
+                    {
+                        return default;
+                    }
+                }
+                else if (MemberSignatureComparer.RuntimeExplicitImplementationSignatureComparer.Equals(implementingMethod, interfaceMethod))
+                {
+                    return (null, (implementingMethod, interfaceMethod));
+                }
             }
 
-            return new SynthesizedExplicitImplementationForwardingMethod(interfaceMethod, implementingMethod, this);
+            return (new SynthesizedExplicitImplementationForwardingMethod(interfaceMethod, implementingMethod, this), null);
         }
 
+#nullable disable
+
         /// <summary>
         /// The CLR will only look for an implementation of an interface method in a type that
         ///   1) declares that it implements that interface; or
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberMethodSymbol.cs
index 907bb7a56e9ab..6a733d192ad94 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberMethodSymbol.cs
@@ -436,7 +436,7 @@ internal override bool IsMetadataNewSlot(bool ignoreInterfaceImplementationChang
             // in NamedTypeSymbolAdapter.cs).
             return this.IsOverride ?
                 this.RequiresExplicitOverride(out _) :
-                this.IsMetadataVirtual(ignoreInterfaceImplementationChanges);
+                !this.IsStatic && this.IsMetadataVirtual(ignoreInterfaceImplementationChanges);
         }
 
         // TODO (tomat): sealed?
@@ -447,6 +447,7 @@ internal override bool IsMetadataVirtual(bool ignoreInterfaceImplementationChang
 
         internal void EnsureMetadataVirtual()
         {
+            Debug.Assert(!this.IsStatic);
             this.flags.EnsureMetadataVirtual();
         }
 
@@ -969,7 +970,8 @@ protected void CheckFeatureAvailabilityAndRuntimeSupport(SyntaxNode declarationS
         {
             if (_containingType.IsInterface)
             {
-                if (hasBody || IsExplicitInterfaceImplementation)
+                if ((!IsStatic || MethodKind is MethodKind.StaticConstructor) &&
+                    (hasBody || IsExplicitInterfaceImplementation))
                 {
                     Binder.CheckFeatureAvailability(declarationSyntax, MessageID.IDS_DefaultInterfaceImplementation, diagnostics, location);
                 }
@@ -978,6 +980,11 @@ protected void CheckFeatureAvailabilityAndRuntimeSupport(SyntaxNode declarationS
                 {
                     diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation, location);
                 }
+
+                if (!hasBody && IsAbstract && IsStatic && !ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)
+                {
+                    diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, location);
+                }
             }
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs
index 503c3ffdaf5e6..38add35774f99 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs
@@ -8,7 +8,6 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Threading;
@@ -975,7 +974,6 @@ static UnmanagedCallersOnlyAttributeData DecodeUnmanagedCallersOnlyAttributeData
                 return UnmanagedCallersOnlyAttributeData.Create(callingConventionTypes);
             }
         }
-#nullable disable
 
         internal sealed override void PostDecodeWellKnownAttributes(ImmutableArray<CSharpAttributeData> boundAttributes, ImmutableArray<AttributeSyntax> allAttributeSyntaxNodes, BindingDiagnosticBag diagnostics, AttributeLocation symbolPart, WellKnownAttributeData decodedData)
         {
@@ -1032,38 +1030,57 @@ internal sealed override void PostDecodeWellKnownAttributes(ImmutableArray<CShar
         }
 
         protected void AsyncMethodChecks(BindingDiagnosticBag diagnostics)
+        {
+            AsyncMethodChecks(verifyReturnType: true, this.Locations[0], diagnostics);
+        }
+
+        protected void AsyncMethodChecks(bool verifyReturnType, Location errorLocation, BindingDiagnosticBag diagnostics)
         {
             if (IsAsync)
             {
-                var errorLocation = this.Locations[0];
                 bool hasErrors = false;
 
-                if (this.RefKind != RefKind.None)
+                if (verifyReturnType)
                 {
-                    var returnTypeSyntax = this.SyntaxNode switch
+                    if (this.RefKind != RefKind.None)
                     {
-                        MethodDeclarationSyntax { ReturnType: var methodReturnType } => methodReturnType,
-                        LocalFunctionStatementSyntax { ReturnType: var localReturnType } => localReturnType,
-                        var unexpected => throw ExceptionUtilities.UnexpectedValue(unexpected)
-                    };
+                        var returnTypeSyntax = this.SyntaxNode switch
+                        {
+                            MethodDeclarationSyntax { ReturnType: var methodReturnType } => methodReturnType,
+                            LocalFunctionStatementSyntax { ReturnType: var localReturnType } => localReturnType,
+                            ParenthesizedLambdaExpressionSyntax { ReturnType: { } lambdaReturnType } => lambdaReturnType,
+                            var unexpected => throw ExceptionUtilities.UnexpectedValue(unexpected)
+                        };
 
-                    ReportBadRefToken(returnTypeSyntax, diagnostics);
-                    hasErrors = true;
+                        ReportBadRefToken(returnTypeSyntax, diagnostics);
+                        hasErrors = true;
+                    }
+                    else if (isBadAsyncReturn(this))
+                    {
+                        diagnostics.Add(ErrorCode.ERR_BadAsyncReturn, errorLocation);
+                        hasErrors = true;
+                    }
                 }
-                else if (ReturnType.IsBadAsyncReturn(this.DeclaringCompilation))
+
+                if (this.HasAsyncMethodBuilderAttribute(out _))
                 {
-                    diagnostics.Add(ErrorCode.ERR_BadAsyncReturn, errorLocation);
-                    hasErrors = true;
+                    hasErrors |= MessageID.IDS_AsyncMethodBuilderOverride.CheckFeatureAvailability(diagnostics, this.DeclaringCompilation, errorLocation);
                 }
 
-                for (NamedTypeSymbol curr = this.ContainingType; (object)curr != null; curr = curr.ContainingType)
+                // Avoid checking attributes on containing types to avoid a potential cycle when a lambda
+                // is used in an attribute argument - see https://github.com/dotnet/roslyn/issues/54074.
+                // (ERR_SecurityCriticalOrSecuritySafeCriticalOnAsyncInClassOrStruct was never reported
+                // for lambda expressions and is not a .NET Core scenario so it's not necessary to handle.)
+                if (this.MethodKind != MethodKind.LambdaMethod)
                 {
-                    var sourceNamedTypeSymbol = curr as SourceNamedTypeSymbol;
-                    if ((object)sourceNamedTypeSymbol != null && sourceNamedTypeSymbol.HasSecurityCriticalAttributes)
+                    for (NamedTypeSymbol curr = this.ContainingType; (object)curr != null; curr = curr.ContainingType)
                     {
-                        diagnostics.Add(ErrorCode.ERR_SecurityCriticalOrSecuritySafeCriticalOnAsyncInClassOrStruct, errorLocation);
-                        hasErrors = true;
-                        break;
+                        if (curr is SourceNamedTypeSymbol { HasSecurityCriticalAttributes: true })
+                        {
+                            diagnostics.Add(ErrorCode.ERR_SecurityCriticalOrSecuritySafeCriticalOnAsyncInClassOrStruct, errorLocation);
+                            hasErrors = true;
+                            break;
+                        }
                     }
                 }
 
@@ -1099,6 +1116,18 @@ protected void AsyncMethodChecks(BindingDiagnosticBag diagnostics)
                     }
                 }
             }
+
+            static bool isBadAsyncReturn(MethodSymbol methodSymbol)
+            {
+                var returnType = methodSymbol.ReturnType;
+                var declaringCompilation = methodSymbol.DeclaringCompilation;
+                return !returnType.IsErrorType() &&
+                    !returnType.IsVoidType() &&
+                    !returnType.IsIAsyncEnumerableType(declaringCompilation) &&
+                    !returnType.IsIAsyncEnumeratorType(declaringCompilation) &&
+                    !methodSymbol.IsAsyncEffectivelyReturningTask(declaringCompilation) &&
+                    !methodSymbol.IsAsyncEffectivelyReturningGenericTask(declaringCompilation);
+            }
         }
 
         private static FlowAnalysisAnnotations DecodeReturnTypeAnnotationAttributes(ReturnTypeWellKnownAttributeData attributeData)
@@ -1194,7 +1223,7 @@ internal override bool HasDeclarativeSecurity
             var wellKnownData = (MethodWellKnownAttributeData)attributesBag.DecodedWellKnownAttributeData;
             if (wellKnownData != null)
             {
-                SecurityWellKnownAttributeData securityData = wellKnownData.SecurityInformation;
+                SecurityWellKnownAttributeData? securityData = wellKnownData.SecurityInformation;
                 if (securityData != null)
                 {
                     return securityData.GetSecurityAttributes(attributesBag.Attributes);
@@ -1204,13 +1233,13 @@ internal override bool HasDeclarativeSecurity
             return SpecializedCollections.EmptyEnumerable<Cci.SecurityAttribute>();
         }
 
-        public override DllImportData GetDllImportData()
+        public override DllImportData? GetDllImportData()
         {
             var data = this.GetDecodedWellKnownAttributeData();
             return data != null ? data.DllImportPlatformInvokeData : null;
         }
 
-        internal override MarshalPseudoCustomAttributeData ReturnValueMarshallingInformation
+        internal override MarshalPseudoCustomAttributeData? ReturnValueMarshallingInformation
         {
             get
             {
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.AliasesAndUsings.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.AliasesAndUsings.cs
index ab846338eba59..ccb5b049a620d 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.AliasesAndUsings.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.AliasesAndUsings.cs
@@ -320,7 +320,7 @@ private MergedGlobalAliasesAndUsings GetMergedGlobalAliasesAndUsings(ConsList<Ty
                                         {
                                             if (!uniqueUsings.Add(namespaceOrType.NamespaceOrType))
                                             {
-                                                diagnostics.Add(ErrorCode.WRN_DuplicateUsing, namespaceOrType.UsingDirective!.Name.Location, namespaceOrType.NamespaceOrType);
+                                                diagnostics.Add(ErrorCode.HDN_DuplicateWithGlobalUsing, namespaceOrType.UsingDirective!.Name.Location, namespaceOrType.NamespaceOrType);
                                             }
                                             else
                                             {
@@ -635,6 +635,7 @@ UsingsAndDiagnostics buildUsings(
                     Binder? declarationBinder = null;
 
                     PooledHashSet<NamespaceOrTypeSymbol>? uniqueUsings = null;
+                    PooledHashSet<NamespaceOrTypeSymbol>? uniqueGlobalUsings = null;
 
                     foreach (var usingDirective in usingDirectives)
                     {
@@ -737,7 +738,10 @@ UsingsAndDiagnostics buildUsings(
                                 }
                                 else if (!getOrCreateUniqueUsings(ref uniqueUsings, globalUsingNamespacesOrTypes).Add(imported))
                                 {
-                                    diagnostics.Add(ErrorCode.WRN_DuplicateUsing, usingDirective.Name.Location, imported);
+                                    diagnostics.Add(!globalUsingNamespacesOrTypes.IsEmpty && getOrCreateUniqueGlobalUsingsNotInTree(ref uniqueGlobalUsings, globalUsingNamespacesOrTypes, declarationSyntax.SyntaxTree).Contains(imported) ?
+                                                            ErrorCode.HDN_DuplicateWithGlobalUsing :
+                                                            ErrorCode.WRN_DuplicateUsing,
+                                                    usingDirective.Name.Location, imported);
                                 }
                                 else
                                 {
@@ -755,7 +759,10 @@ UsingsAndDiagnostics buildUsings(
                                     var importedType = (NamedTypeSymbol)imported;
                                     if (!getOrCreateUniqueUsings(ref uniqueUsings, globalUsingNamespacesOrTypes).Add(importedType))
                                     {
-                                        diagnostics.Add(ErrorCode.WRN_DuplicateUsing, usingDirective.Name.Location, importedType);
+                                        diagnostics.Add(!globalUsingNamespacesOrTypes.IsEmpty && getOrCreateUniqueGlobalUsingsNotInTree(ref uniqueGlobalUsings, globalUsingNamespacesOrTypes, declarationSyntax.SyntaxTree).Contains(imported) ?
+                                                            ErrorCode.HDN_DuplicateWithGlobalUsing :
+                                                            ErrorCode.WRN_DuplicateUsing,
+                                                        usingDirective.Name.Location, importedType);
                                     }
                                     else
                                     {
@@ -782,6 +789,7 @@ UsingsAndDiagnostics buildUsings(
                     }
 
                     uniqueUsings?.Free();
+                    uniqueGlobalUsings?.Free();
 
                     if (diagnostics.IsEmptyWithoutResolution)
                     {
@@ -807,6 +815,17 @@ static PooledHashSet<NamespaceOrTypeSymbol> getOrCreateUniqueUsings(ref PooledHa
                         return uniqueUsings;
                     }
 
+                    static PooledHashSet<NamespaceOrTypeSymbol> getOrCreateUniqueGlobalUsingsNotInTree(ref PooledHashSet<NamespaceOrTypeSymbol>? uniqueUsings, ImmutableArray<NamespaceOrTypeAndUsingDirective> globalUsingNamespacesOrTypes, SyntaxTree tree)
+                    {
+                        if (uniqueUsings is null)
+                        {
+                            uniqueUsings = SpecializedSymbolCollections.GetPooledSymbolHashSetInstance<NamespaceOrTypeSymbol>();
+                            uniqueUsings.AddAll(globalUsingNamespacesOrTypes.Where(n => n.UsingDirectiveReference?.SyntaxTree != tree).Select(n => n.NamespaceOrType));
+                        }
+
+                        return uniqueUsings;
+                    }
+
                     static ArrayBuilder<NamespaceOrTypeAndUsingDirective> getOrCreateUsingsBuilder(ref ArrayBuilder<NamespaceOrTypeAndUsingDirective>? usings, ImmutableArray<NamespaceOrTypeAndUsingDirective> globalUsingNamespacesOrTypes)
                     {
                         if (usings is null)
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
index 05c7da7a1fdb0..cd6f412d23a21 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
@@ -9,7 +9,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Threading;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
@@ -28,9 +28,9 @@ internal sealed partial class SourceNamespaceSymbol : NamespaceSymbol
         private Dictionary<string, ImmutableArray<NamedTypeSymbol>> _nameToTypeMembersMap;
         private ImmutableArray<Symbol> _lazyAllMembers;
         private ImmutableArray<NamedTypeSymbol> _lazyTypeMembersUnordered;
-        private readonly ImmutableDictionary<SingleNamespaceDeclaration, AliasesAndUsings> _aliasesAndUsings;
+        private readonly ImmutableSegmentedDictionary<SingleNamespaceDeclaration, AliasesAndUsings> _aliasesAndUsings;
 #if DEBUG
-        private readonly ImmutableDictionary<SingleNamespaceDeclaration, AliasesAndUsings> _aliasesAndUsingsForAsserts;
+        private readonly ImmutableSegmentedDictionary<SingleNamespaceDeclaration, AliasesAndUsings> _aliasesAndUsingsForAsserts;
 #endif
         private MergedGlobalAliasesAndUsings _lazyMergedGlobalAliasesAndUsings;
 
@@ -49,9 +49,9 @@ internal SourceNamespaceSymbol(
             _container = container;
             _mergedDeclaration = mergedDeclaration;
 
-            var builder = ImmutableDictionary.CreateBuilder<SingleNamespaceDeclaration, AliasesAndUsings>(ReferenceEqualityComparer.Instance);
+            var builder = ImmutableSegmentedDictionary.CreateBuilder<SingleNamespaceDeclaration, AliasesAndUsings>(ReferenceEqualityComparer.Instance);
 #if DEBUG
-            var builderForAsserts = ImmutableDictionary.CreateBuilder<SingleNamespaceDeclaration, AliasesAndUsings>(ReferenceEqualityComparer.Instance);
+            var builderForAsserts = ImmutableSegmentedDictionary.CreateBuilder<SingleNamespaceDeclaration, AliasesAndUsings>(ReferenceEqualityComparer.Instance);
 #endif
             foreach (var singleDeclaration in mergedDeclaration.Declarations)
             {
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs
new file mode 100644
index 0000000000000..1d3ba796909c0
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs
@@ -0,0 +1,275 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols
+{
+    internal abstract class SourceOrdinaryMethodOrUserDefinedOperatorSymbol : SourceMemberMethodSymbol
+    {
+        private ImmutableArray<MethodSymbol> _lazyExplicitInterfaceImplementations;
+        private ImmutableArray<CustomModifier> _lazyRefCustomModifiers;
+        private ImmutableArray<ParameterSymbol> _lazyParameters;
+        private TypeWithAnnotations _lazyReturnType;
+
+        protected SourceOrdinaryMethodOrUserDefinedOperatorSymbol(NamedTypeSymbol containingType, SyntaxReference syntaxReferenceOpt, Location location, bool isIterator)
+            : base(containingType, syntaxReferenceOpt, location, isIterator)
+        {
+        }
+
+        protected abstract Location ReturnTypeLocation { get; }
+
+        public sealed override bool ReturnsVoid
+        {
+            get
+            {
+                LazyMethodChecks();
+                return base.ReturnsVoid;
+            }
+        }
+
+        protected MethodSymbol? MethodChecks(TypeWithAnnotations returnType, ImmutableArray<ParameterSymbol> parameters, BindingDiagnosticBag diagnostics)
+        {
+            _lazyReturnType = returnType;
+            _lazyParameters = parameters;
+
+            // set ReturnsVoid flag
+            this.SetReturnsVoid(_lazyReturnType.IsVoidType());
+
+            this.CheckEffectiveAccessibility(_lazyReturnType, _lazyParameters, diagnostics);
+
+            var location = locations[0];
+            // Checks taken from MemberDefiner::defineMethod
+            if (this.Name == WellKnownMemberNames.DestructorName && this.ParameterCount == 0 && this.Arity == 0 && this.ReturnsVoid)
+            {
+                diagnostics.Add(ErrorCode.WRN_FinalizeMethod, location);
+            }
+
+            ExtensionMethodChecks(diagnostics);
+
+            if (IsPartial)
+            {
+                if (MethodKind == MethodKind.ExplicitInterfaceImplementation)
+                {
+                    diagnostics.Add(ErrorCode.ERR_PartialMethodNotExplicit, location);
+                }
+
+                if (!ContainingType.IsPartial())
+                {
+                    diagnostics.Add(ErrorCode.ERR_PartialMethodOnlyInPartialClass, location);
+                }
+            }
+
+            if (!IsPartial)
+            {
+                LazyAsyncMethodChecks(CancellationToken.None);
+                Debug.Assert(state.HasComplete(CompletionPart.FinishAsyncMethodChecks));
+            }
+
+            // The runtime will not treat this method as an override or implementation of another
+            // method unless both the signatures and the custom modifiers match.  Hence, in the
+            // case of overrides and *explicit* implementations, we need to copy the custom modifiers
+            // that are in the signature of the overridden/implemented method.  (From source, we know
+            // that there can only be one such method, so there are no conflicts.)  This is
+            // unnecessary for implicit implementations because, if the custom modifiers don't match,
+            // we'll insert a bridge method (an explicit implementation that delegates to the implicit
+            // implementation) with the correct custom modifiers 
+            // (see SourceMemberContainerTypeSymbol.SynthesizeInterfaceMemberImplementation).
+
+            // This value may not be correct, but we need something while we compute this.OverriddenMethod.
+            // May be re-assigned below.
+            Debug.Assert(_lazyReturnType.CustomModifiers.IsEmpty);
+            _lazyRefCustomModifiers = ImmutableArray<CustomModifier>.Empty;
+
+            MethodSymbol? overriddenOrExplicitlyImplementedMethod = null;
+
+            // Note: we're checking if the syntax indicates explicit implementation rather,
+            // than if explicitInterfaceType is null because we don't want to look for an
+            // overridden property if this is supposed to be an explicit implementation.
+            if (MethodKind != MethodKind.ExplicitInterfaceImplementation)
+            {
+                Debug.Assert(_lazyExplicitInterfaceImplementations.IsDefault);
+                _lazyExplicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty;
+
+                // If this method is an override, we may need to copy custom modifiers from
+                // the overridden method (so that the runtime will recognize it as an override).
+                // We check for this case here, while we can still modify the parameters and
+                // return type without losing the appearance of immutability.
+                if (this.IsOverride)
+                {
+                    // This computation will necessarily be performed with partially incomplete
+                    // information.  There is no way we can determine the complete signature
+                    // (i.e. including custom modifiers) until we have found the method that
+                    // this method overrides.  To accommodate this, MethodSymbol.OverriddenOrHiddenMembers
+                    // is written to allow relaxed matching of custom modifiers for source methods,
+                    // on the assumption that they will be updated appropriately.
+                    overriddenOrExplicitlyImplementedMethod = this.OverriddenMethod;
+
+                    if ((object)overriddenOrExplicitlyImplementedMethod != null)
+                    {
+                        CustomModifierUtils.CopyMethodCustomModifiers(overriddenOrExplicitlyImplementedMethod, this, out _lazyReturnType,
+                                                                      out _lazyRefCustomModifiers,
+                                                                      out _lazyParameters, alsoCopyParamsModifier: true);
+                    }
+                }
+                else if (RefKind == RefKind.RefReadOnly)
+                {
+                    var modifierType = Binder.GetWellKnownType(DeclaringCompilation, WellKnownType.System_Runtime_InteropServices_InAttribute, diagnostics, ReturnTypeLocation);
+
+                    _lazyRefCustomModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType));
+                }
+            }
+            else if (ExplicitInterfaceType is not null)
+            {
+                //do this last so that it can assume the method symbol is constructed (except for ExplicitInterfaceImplementation)
+                overriddenOrExplicitlyImplementedMethod = FindExplicitlyImplementedMethod(diagnostics);
+
+                if (overriddenOrExplicitlyImplementedMethod is not null)
+                {
+                    Debug.Assert(_lazyExplicitInterfaceImplementations.IsDefault);
+                    _lazyExplicitInterfaceImplementations = ImmutableArray.Create<MethodSymbol>(overriddenOrExplicitlyImplementedMethod);
+
+                    CustomModifierUtils.CopyMethodCustomModifiers(overriddenOrExplicitlyImplementedMethod, this, out _lazyReturnType,
+                                                                  out _lazyRefCustomModifiers,
+                                                                  out _lazyParameters, alsoCopyParamsModifier: false);
+                    this.FindExplicitlyImplementedMemberVerification(overriddenOrExplicitlyImplementedMethod, diagnostics);
+                    TypeSymbol.CheckNullableReferenceTypeMismatchOnImplementingMember(this.ContainingType, this, overriddenOrExplicitlyImplementedMethod, isExplicit: true, diagnostics);
+                }
+                else
+                {
+                    Debug.Assert(_lazyExplicitInterfaceImplementations.IsDefault);
+                    _lazyExplicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty;
+
+                    Debug.Assert(_lazyReturnType.CustomModifiers.IsEmpty);
+                }
+            }
+
+            return overriddenOrExplicitlyImplementedMethod;
+        }
+
+        protected abstract void ExtensionMethodChecks(BindingDiagnosticBag diagnostics);
+
+        protected abstract MethodSymbol? FindExplicitlyImplementedMethod(BindingDiagnosticBag diagnostics);
+
+        protected abstract TypeSymbol? ExplicitInterfaceType { get; }
+
+        internal sealed override int ParameterCount
+        {
+            get
+            {
+                if (!_lazyParameters.IsDefault)
+                {
+                    int result = _lazyParameters.Length;
+                    Debug.Assert(result == GetParameterCountFromSyntax());
+                    return result;
+                }
+
+                return GetParameterCountFromSyntax();
+            }
+        }
+
+        protected abstract int GetParameterCountFromSyntax();
+
+        public sealed override ImmutableArray<ParameterSymbol> Parameters
+        {
+            get
+            {
+                LazyMethodChecks();
+                return _lazyParameters;
+            }
+        }
+
+        public sealed override TypeWithAnnotations ReturnTypeWithAnnotations
+        {
+            get
+            {
+                LazyMethodChecks();
+                return _lazyReturnType;
+            }
+        }
+
+        internal sealed override bool IsExplicitInterfaceImplementation
+        {
+            get
+            {
+                return MethodKind == MethodKind.ExplicitInterfaceImplementation;
+            }
+        }
+
+        public sealed override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
+        {
+            get
+            {
+                LazyMethodChecks();
+                return _lazyExplicitInterfaceImplementations;
+            }
+        }
+
+        public sealed override ImmutableArray<CustomModifier> RefCustomModifiers
+        {
+            get
+            {
+                LazyMethodChecks();
+                return _lazyRefCustomModifiers;
+            }
+        }
+
+        internal override void AfterAddingTypeMembersChecks(ConversionsBase conversions, BindingDiagnosticBag diagnostics)
+        {
+            base.AfterAddingTypeMembersChecks(conversions, diagnostics);
+
+            var location = ReturnTypeLocation;
+            var compilation = DeclaringCompilation;
+
+            Debug.Assert(location != null);
+
+            // Check constraints on return type and parameters. Note: Dev10 uses the
+            // method name location for any such errors. We'll do the same for return
+            // type errors but for parameter errors, we'll use the parameter location.
+            CheckConstraintsForExplicitInterfaceType(conversions, diagnostics);
+
+            this.ReturnType.CheckAllConstraints(compilation, conversions, this.Locations[0], diagnostics);
+
+            foreach (var parameter in this.Parameters)
+            {
+                parameter.Type.CheckAllConstraints(compilation, conversions, parameter.Locations[0], diagnostics);
+            }
+
+            PartialMethodChecks(diagnostics);
+
+            if (RefKind == RefKind.RefReadOnly)
+            {
+                compilation.EnsureIsReadOnlyAttributeExists(diagnostics, location, modifyCompilation: true);
+            }
+
+            ParameterHelpers.EnsureIsReadOnlyAttributeExists(compilation, Parameters, diagnostics, modifyCompilation: true);
+
+            if (ReturnType.ContainsNativeInteger())
+            {
+                compilation.EnsureNativeIntegerAttributeExists(diagnostics, location, modifyCompilation: true);
+            }
+
+            ParameterHelpers.EnsureNativeIntegerAttributeExists(compilation, Parameters, diagnostics, modifyCompilation: true);
+
+            if (compilation.ShouldEmitNullableAttributes(this) && ReturnTypeWithAnnotations.NeedsNullableAttribute())
+            {
+                compilation.EnsureNullableAttributeExists(diagnostics, location, modifyCompilation: true);
+            }
+
+            ParameterHelpers.EnsureNullableAttributeExists(compilation, this, Parameters, diagnostics, modifyCompilation: true);
+        }
+
+        protected abstract void CheckConstraintsForExplicitInterfaceType(ConversionsBase conversions, BindingDiagnosticBag diagnostics);
+
+        protected abstract void PartialMethodChecks(BindingDiagnosticBag diagnostics);
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodSymbol.cs
index 91fc881cf1cd2..f136e698e2400 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodSymbol.cs
@@ -57,8 +57,7 @@ public static SourceOrdinaryMethodSymbol CreateMethodSymbol(
             var nameToken = syntax.Identifier;
 
             TypeSymbol explicitInterfaceType;
-            string discardedAliasQualifier;
-            var name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(bodyBinder, interfaceSpecifier, nameToken.ValueText, diagnostics, out explicitInterfaceType, out discardedAliasQualifier);
+            var name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(bodyBinder, interfaceSpecifier, nameToken.ValueText, diagnostics, out explicitInterfaceType, aliasQualifierOpt: out _);
             var location = new SourceLocation(nameToken);
 
             var methodKind = interfaceSpecifier == null
@@ -276,7 +275,7 @@ protected override void ExtensionMethodChecks(BindingDiagnosticBag diagnostics)
         protected override MethodSymbol FindExplicitlyImplementedMethod(BindingDiagnosticBag diagnostics)
         {
             var syntax = GetSyntax();
-            return this.FindExplicitlyImplementedMethod(_explicitInterfaceType, syntax.Identifier.ValueText, syntax.ExplicitInterfaceSpecifier, diagnostics);
+            return this.FindExplicitlyImplementedMethod(isOperator: false, _explicitInterfaceType, syntax.Identifier.ValueText, syntax.ExplicitInterfaceSpecifier, diagnostics);
         }
 
         protected override Location ReturnTypeLocation => GetSyntax().ReturnType.Location;
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodSymbolBase.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodSymbolBase.cs
index 80f4b652af6fe..a122f3ff342e0 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodSymbolBase.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodSymbolBase.cs
@@ -21,16 +21,11 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
     /// on any specific kind of syntax node associated with it. Any syntax node is good enough
     /// for it.
     /// </summary>
-    internal abstract class SourceOrdinaryMethodSymbolBase : SourceMemberMethodSymbol
+    internal abstract class SourceOrdinaryMethodSymbolBase : SourceOrdinaryMethodOrUserDefinedOperatorSymbol
     {
         private readonly ImmutableArray<TypeParameterSymbol> _typeParameters;
         private readonly string _name;
 
-        private ImmutableArray<MethodSymbol> _lazyExplicitInterfaceImplementations;
-        private ImmutableArray<CustomModifier> _lazyRefCustomModifiers;
-        private ImmutableArray<ParameterSymbol> _lazyParameters;
-        private TypeWithAnnotations _lazyReturnType;
-
         protected SourceOrdinaryMethodSymbolBase(
             NamedTypeSymbol containingType,
             string name,
@@ -60,7 +55,8 @@ protected SourceOrdinaryMethodSymbolBase(
             DeclarationModifiers declarationModifiers;
             (declarationModifiers, HasExplicitAccessModifier) = this.MakeModifiers(methodKind, isPartial, hasBody, location, diagnostics);
 
-            var isMetadataVirtualIgnoringModifiers = methodKind == MethodKind.ExplicitInterfaceImplementation; //explicit impls must be marked metadata virtual
+            //explicit impls must be marked metadata virtual unless static
+            var isMetadataVirtualIgnoringModifiers = methodKind == MethodKind.ExplicitInterfaceImplementation && (declarationModifiers & DeclarationModifiers.Static) == 0;
 
             this.MakeFlags(methodKind, declarationModifiers, returnsVoid, isExtensionMethod: isExtensionMethod, isNullableAnalysisEnabled: isNullableAnalysisEnabled, isMetadataVirtualIgnoringModifiers: isMetadataVirtualIgnoringModifiers);
 
@@ -82,133 +78,14 @@ protected SourceOrdinaryMethodSymbolBase(
 
         protected abstract ImmutableArray<TypeParameterSymbol> MakeTypeParameters(CSharpSyntaxNode node, BindingDiagnosticBag diagnostics);
 
-        public override bool ReturnsVoid
-        {
-            get
-            {
-                LazyMethodChecks();
-                return base.ReturnsVoid;
-            }
-        }
-
+#nullable enable
         protected override void MethodChecks(BindingDiagnosticBag diagnostics)
         {
             Debug.Assert(this.MethodKind != MethodKind.UserDefinedOperator, "SourceUserDefinedOperatorSymbolBase overrides this");
 
-            ImmutableArray<TypeParameterConstraintClause> declaredConstraints;
-            bool isVararg;
-            (_lazyReturnType, _lazyParameters, isVararg, declaredConstraints) = MakeParametersAndBindReturnType(diagnostics);
-
-            // set ReturnsVoid flag
-            this.SetReturnsVoid(_lazyReturnType.IsVoidType());
-
-            this.CheckEffectiveAccessibility(_lazyReturnType, _lazyParameters, diagnostics);
-
-            var location = locations[0];
-            // Checks taken from MemberDefiner::defineMethod
-            if (this.Name == WellKnownMemberNames.DestructorName && this.ParameterCount == 0 && this.Arity == 0 && this.ReturnsVoid)
-            {
-                diagnostics.Add(ErrorCode.WRN_FinalizeMethod, location);
-            }
-
-            ExtensionMethodChecks(diagnostics);
-
-            if (IsPartial)
-            {
-                if (MethodKind == MethodKind.ExplicitInterfaceImplementation)
-                {
-                    diagnostics.Add(ErrorCode.ERR_PartialMethodNotExplicit, location);
-                }
-
-                if (!ContainingType.IsPartial())
-                {
-                    diagnostics.Add(ErrorCode.ERR_PartialMethodOnlyInPartialClass, location);
-                }
-            }
-
-            if (!IsPartial)
-            {
-                LazyAsyncMethodChecks(CancellationToken.None);
-                Debug.Assert(state.HasComplete(CompletionPart.FinishAsyncMethodChecks));
-            }
-
-            // The runtime will not treat this method as an override or implementation of another
-            // method unless both the signatures and the custom modifiers match.  Hence, in the
-            // case of overrides and *explicit* implementations, we need to copy the custom modifiers
-            // that are in the signature of the overridden/implemented method.  (From source, we know
-            // that there can only be one such method, so there are no conflicts.)  This is
-            // unnecessary for implicit implementations because, if the custom modifiers don't match,
-            // we'll insert a bridge method (an explicit implementation that delegates to the implicit
-            // implementation) with the correct custom modifiers 
-            // (see SourceMemberContainerTypeSymbol.SynthesizeInterfaceMemberImplementation).
-
-            // This value may not be correct, but we need something while we compute this.OverriddenMethod.
-            // May be re-assigned below.
-            Debug.Assert(_lazyReturnType.CustomModifiers.IsEmpty);
-            _lazyRefCustomModifiers = ImmutableArray<CustomModifier>.Empty;
+            var (returnType, parameters, isVararg, declaredConstraints) = MakeParametersAndBindReturnType(diagnostics);
 
-            MethodSymbol overriddenOrExplicitlyImplementedMethod = null;
-
-            // Note: we're checking if the syntax indicates explicit implementation rather,
-            // than if explicitInterfaceType is null because we don't want to look for an
-            // overridden property if this is supposed to be an explicit implementation.
-            if (MethodKind != MethodKind.ExplicitInterfaceImplementation)
-            {
-                Debug.Assert(_lazyExplicitInterfaceImplementations.IsDefault);
-                _lazyExplicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty;
-
-                // If this method is an override, we may need to copy custom modifiers from
-                // the overridden method (so that the runtime will recognize it as an override).
-                // We check for this case here, while we can still modify the parameters and
-                // return type without losing the appearance of immutability.
-                if (this.IsOverride)
-                {
-                    // This computation will necessarily be performed with partially incomplete
-                    // information.  There is no way we can determine the complete signature
-                    // (i.e. including custom modifiers) until we have found the method that
-                    // this method overrides.  To accommodate this, MethodSymbol.OverriddenOrHiddenMembers
-                    // is written to allow relaxed matching of custom modifiers for source methods,
-                    // on the assumption that they will be updated appropriately.
-                    overriddenOrExplicitlyImplementedMethod = this.OverriddenMethod;
-
-                    if ((object)overriddenOrExplicitlyImplementedMethod != null)
-                    {
-                        CustomModifierUtils.CopyMethodCustomModifiers(overriddenOrExplicitlyImplementedMethod, this, out _lazyReturnType,
-                                                                      out _lazyRefCustomModifiers,
-                                                                      out _lazyParameters, alsoCopyParamsModifier: true);
-                    }
-                }
-                else if (RefKind == RefKind.RefReadOnly)
-                {
-                    var modifierType = Binder.GetWellKnownType(DeclaringCompilation, WellKnownType.System_Runtime_InteropServices_InAttribute, diagnostics, ReturnTypeLocation);
-
-                    _lazyRefCustomModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType));
-                }
-            }
-            else if ((object)ExplicitInterfaceType != null)
-            {
-                //do this last so that it can assume the method symbol is constructed (except for ExplicitInterfaceImplementation)
-                overriddenOrExplicitlyImplementedMethod = FindExplicitlyImplementedMethod(diagnostics);
-
-                if ((object)overriddenOrExplicitlyImplementedMethod != null)
-                {
-                    Debug.Assert(_lazyExplicitInterfaceImplementations.IsDefault);
-                    _lazyExplicitInterfaceImplementations = ImmutableArray.Create<MethodSymbol>(overriddenOrExplicitlyImplementedMethod);
-
-                    CustomModifierUtils.CopyMethodCustomModifiers(overriddenOrExplicitlyImplementedMethod, this, out _lazyReturnType,
-                                                                  out _lazyRefCustomModifiers,
-                                                                  out _lazyParameters, alsoCopyParamsModifier: false);
-                    this.FindExplicitlyImplementedMemberVerification(overriddenOrExplicitlyImplementedMethod, diagnostics);
-                    TypeSymbol.CheckNullableReferenceTypeMismatchOnImplementingMember(this.ContainingType, this, overriddenOrExplicitlyImplementedMethod, isExplicit: true, diagnostics);
-                }
-                else
-                {
-                    Debug.Assert(_lazyExplicitInterfaceImplementations.IsDefault);
-                    _lazyExplicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty;
-
-                    Debug.Assert(_lazyReturnType.CustomModifiers.IsEmpty);
-                }
-            }
+            MethodSymbol? overriddenOrExplicitlyImplementedMethod = MethodChecks(returnType, parameters, diagnostics);
 
             if (!declaredConstraints.IsDefault && overriddenOrExplicitlyImplementedMethod is object)
             {
@@ -249,19 +126,12 @@ protected override void MethodChecks(BindingDiagnosticBag diagnostics)
                 }
             }
 
-            CheckModifiers(MethodKind == MethodKind.ExplicitInterfaceImplementation, isVararg, HasAnyBody, location, diagnostics);
+            CheckModifiers(MethodKind == MethodKind.ExplicitInterfaceImplementation, isVararg, HasAnyBody, locations[0], diagnostics);
         }
+#nullable disable
 
         protected abstract (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters, bool IsVararg, ImmutableArray<TypeParameterConstraintClause> DeclaredConstraintsForOverrideOrImplementation) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics);
 
-        protected abstract void ExtensionMethodChecks(BindingDiagnosticBag diagnostics);
-
-        protected abstract MethodSymbol FindExplicitlyImplementedMethod(BindingDiagnosticBag diagnostics);
-
-        protected abstract Location ReturnTypeLocation { get; }
-
-        protected abstract TypeSymbol ExplicitInterfaceType { get; }
-
         protected abstract bool HasAnyBody { get; }
 
         protected sealed override void LazyAsyncMethodChecks(CancellationToken cancellationToken)
@@ -316,69 +186,8 @@ public override ImmutableArray<Location> Locations
             }
         }
 
-        internal sealed override int ParameterCount
-        {
-            get
-            {
-                if (!_lazyParameters.IsDefault)
-                {
-                    int result = _lazyParameters.Length;
-                    Debug.Assert(result == GetParameterCountFromSyntax());
-                    return result;
-                }
-
-                return GetParameterCountFromSyntax();
-            }
-        }
-
-        protected abstract int GetParameterCountFromSyntax();
-
-        public sealed override ImmutableArray<ParameterSymbol> Parameters
-        {
-            get
-            {
-                LazyMethodChecks();
-                return _lazyParameters;
-            }
-        }
-
-        public sealed override TypeWithAnnotations ReturnTypeWithAnnotations
-        {
-            get
-            {
-                LazyMethodChecks();
-                return _lazyReturnType;
-            }
-        }
-
         public abstract override string GetDocumentationCommentXml(CultureInfo preferredCulture = null, bool expandIncludes = false, CancellationToken cancellationToken = default(CancellationToken));
 
-        internal override bool IsExplicitInterfaceImplementation
-        {
-            get
-            {
-                return MethodKind == MethodKind.ExplicitInterfaceImplementation;
-            }
-        }
-
-        public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
-        {
-            get
-            {
-                LazyMethodChecks();
-                return _lazyExplicitInterfaceImplementations;
-            }
-        }
-
-        public override ImmutableArray<CustomModifier> RefCustomModifiers
-        {
-            get
-            {
-                LazyMethodChecks();
-                return _lazyRefCustomModifiers;
-            }
-        }
-
         public override string Name
         {
             get
@@ -432,10 +241,18 @@ public override string Name
                                                                DeclarationModifiers.AccessibilityMask;
                 }
             }
-            else if (isInterface)
+            else
             {
                 Debug.Assert(isExplicitInterfaceImplementation);
-                allowedModifiers |= DeclarationModifiers.Abstract;
+
+                if (isInterface)
+                {
+                    allowedModifiers |= DeclarationModifiers.Abstract;
+                }
+                else
+                {
+                    allowedModifiers |= DeclarationModifiers.Static;
+                }
             }
 
             allowedModifiers |= DeclarationModifiers.Extern | DeclarationModifiers.Async;
@@ -459,6 +276,8 @@ public override string Name
                 hasExplicitAccessMod = true;
             }
 
+            ModifierUtils.CheckFeatureAvailabilityForStaticAbstractMembersInInterfacesIfNeeded(mods, isExplicitInterfaceImplementation, location, diagnostics);
+
             this.CheckUnsafeModifier(mods, diagnostics);
 
             ModifierUtils.ReportDefaultInterfaceImplementationModifiers(hasBody, mods,
@@ -498,6 +317,8 @@ private static DeclarationModifiers AddImpliedModifiers(DeclarationModifiers mod
 
         private void CheckModifiers(bool isExplicitInterfaceImplementation, bool isVararg, bool hasBody, Location location, BindingDiagnosticBag diagnostics)
         {
+            Debug.Assert(!IsStatic || (!IsVirtual && !IsOverride)); // Otherwise 'virtual' and 'override' should have been reported and cleared earlier.
+
             bool isExplicitInterfaceImplementationInInterface = isExplicitInterfaceImplementation && ContainingType.IsInterface;
 
             if (IsPartial && HasExplicitAccessModifier)
@@ -525,10 +346,10 @@ private void CheckModifiers(bool isExplicitInterfaceImplementation, bool isVarar
             {
                 diagnostics.Add(ErrorCode.ERR_VirtualPrivate, location, this);
             }
-            else if (IsStatic && (IsOverride || IsVirtual || IsAbstract))
+            else if (IsStatic && IsAbstract && !ContainingType.IsInterface)
             {
-                // A static member '{0}' cannot be marked as override, virtual, or abstract
-                diagnostics.Add(ErrorCode.ERR_StaticNotVirtual, location, this);
+                // A static member '{0}' cannot be marked as 'abstract'
+                diagnostics.Add(ErrorCode.ERR_StaticNotVirtual, location, ModifierUtils.ConvertSingleModifierToSyntaxText(DeclarationModifiers.Abstract));
             }
             else if (IsOverride && (IsNew || IsVirtual))
             {
@@ -545,10 +366,10 @@ private void CheckModifiers(bool isExplicitInterfaceImplementation, bool isVarar
                 // The modifier '{0}' is not valid for this item
                 diagnostics.Add(ErrorCode.ERR_BadMemberFlag, location, SyntaxFacts.GetText(SyntaxKind.SealedKeyword));
             }
-            else if (_lazyReturnType.IsStatic)
+            else if (ReturnType.IsStatic)
             {
                 // '{0}': static types cannot be used as return types
-                diagnostics.Add(ErrorFacts.GetStaticClassReturnCode(ContainingType.IsInterfaceType()), location, _lazyReturnType.Type);
+                diagnostics.Add(ErrorFacts.GetStaticClassReturnCode(ContainingType.IsInterfaceType()), location, ReturnType);
             }
             else if (IsAbstract && IsExtern)
             {
@@ -603,7 +424,7 @@ private void CheckModifiers(bool isExplicitInterfaceImplementation, bool isVarar
             {
                 diagnostics.Add(ErrorCode.ERR_InstanceMemberInStaticClass, location, Name);
             }
-            else if (isVararg && (IsGenericMethod || ContainingType.IsGenericType || _lazyParameters.Length > 0 && _lazyParameters[_lazyParameters.Length - 1].IsParams))
+            else if (isVararg && (IsGenericMethod || ContainingType.IsGenericType || Parameters.Length > 0 && Parameters[Parameters.Length - 1].IsParams))
             {
                 diagnostics.Add(ErrorCode.ERR_BadVarargs, location);
             }
@@ -627,54 +448,5 @@ internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, r
                     WellKnownMember.System_Runtime_CompilerServices_ExtensionAttribute__ctor));
             }
         }
-
-        internal override void AfterAddingTypeMembersChecks(ConversionsBase conversions, BindingDiagnosticBag diagnostics)
-        {
-            base.AfterAddingTypeMembersChecks(conversions, diagnostics);
-
-            var location = ReturnTypeLocation;
-            var compilation = DeclaringCompilation;
-
-            Debug.Assert(location != null);
-
-            // Check constraints on return type and parameters. Note: Dev10 uses the
-            // method name location for any such errors. We'll do the same for return
-            // type errors but for parameter errors, we'll use the parameter location.
-            CheckConstraintsForExplicitInterfaceType(conversions, diagnostics);
-
-            this.ReturnType.CheckAllConstraints(compilation, conversions, this.Locations[0], diagnostics);
-
-            foreach (var parameter in this.Parameters)
-            {
-                parameter.Type.CheckAllConstraints(compilation, conversions, parameter.Locations[0], diagnostics);
-            }
-
-            PartialMethodChecks(diagnostics);
-
-            if (RefKind == RefKind.RefReadOnly)
-            {
-                compilation.EnsureIsReadOnlyAttributeExists(diagnostics, location, modifyCompilation: true);
-            }
-
-            ParameterHelpers.EnsureIsReadOnlyAttributeExists(compilation, Parameters, diagnostics, modifyCompilation: true);
-
-            if (ReturnType.ContainsNativeInteger())
-            {
-                compilation.EnsureNativeIntegerAttributeExists(diagnostics, location, modifyCompilation: true);
-            }
-
-            ParameterHelpers.EnsureNativeIntegerAttributeExists(compilation, Parameters, diagnostics, modifyCompilation: true);
-
-            if (compilation.ShouldEmitNullableAttributes(this) && ReturnTypeWithAnnotations.NeedsNullableAttribute())
-            {
-                compilation.EnsureNullableAttributeExists(diagnostics, location, modifyCompilation: true);
-            }
-
-            ParameterHelpers.EnsureNullableAttributeExists(compilation, this, Parameters, diagnostics, modifyCompilation: true);
-        }
-
-        protected abstract void CheckConstraintsForExplicitInterfaceType(ConversionsBase conversions, BindingDiagnosticBag diagnostics);
-
-        protected abstract void PartialMethodChecks(BindingDiagnosticBag diagnostics);
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertyAccessorSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertyAccessorSymbol.cs
index 66e950cdf97fb..474e904934cdb 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertyAccessorSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertyAccessorSymbol.cs
@@ -160,7 +160,7 @@ private SourcePropertyAccessorSymbol(
             // ReturnsVoid property is overridden in this class so
             // returnsVoid argument to MakeFlags is ignored.
             this.MakeFlags(MethodKind.PropertyGet, declarationModifiers, returnsVoid: false, isExtensionMethod: false, isNullableAnalysisEnabled: isNullableAnalysisEnabled,
-                isMetadataVirtualIgnoringModifiers: property.IsExplicitInterfaceImplementation);
+                isMetadataVirtualIgnoringModifiers: property.IsExplicitInterfaceImplementation && (declarationModifiers & DeclarationModifiers.Static) == 0);
 
             CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody: true, diagnostics: diagnostics);
             CheckModifiersForBody(location, diagnostics);
@@ -219,7 +219,7 @@ protected SourcePropertyAccessorSymbol(
             // ReturnsVoid property is overridden in this class so
             // returnsVoid argument to MakeFlags is ignored.
             this.MakeFlags(methodKind, declarationModifiers, returnsVoid: false, isExtensionMethod: false, isNullableAnalysisEnabled: isNullableAnalysisEnabled,
-                isMetadataVirtualIgnoringModifiers: property.IsExplicitInterfaceImplementation);
+                isMetadataVirtualIgnoringModifiers: property.IsExplicitInterfaceImplementation && (declarationModifiers & DeclarationModifiers.Static) == 0);
 
             CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody: hasBody || hasExpressionBody || isAutoPropertyAccessor, diagnostics);
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbol.cs
index ca475dbb3a0a7..f71c881683cec 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbol.cs
@@ -307,10 +307,18 @@ private static DeclarationModifiers MakeModifiers(
                                                                DeclarationModifiers.AccessibilityMask;
                 }
             }
-            else if (isInterface)
+            else
             {
                 Debug.Assert(isExplicitInterfaceImplementation);
-                allowedModifiers |= DeclarationModifiers.Abstract;
+
+                if (isInterface)
+                {
+                    allowedModifiers |= DeclarationModifiers.Abstract;
+                }
+                else if (!isIndexer)
+                {
+                    allowedModifiers |= DeclarationModifiers.Static;
+                }
             }
 
             if (containingType.IsStructType())
@@ -322,6 +330,8 @@ private static DeclarationModifiers MakeModifiers(
 
             var mods = ModifierUtils.MakeAndCheckNontypeMemberModifiers(modifiers, defaultAccess, allowedModifiers, location, diagnostics, out modifierErrors);
 
+            ModifierUtils.CheckFeatureAvailabilityForStaticAbstractMembersInInterfacesIfNeeded(mods, isExplicitInterfaceImplementation, location, diagnostics);
+
             containingType.CheckUnsafeModifier(mods, location, diagnostics);
 
             ModifierUtils.ReportDefaultInterfaceImplementationModifiers(accessorsHaveImplementation, mods,
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs
index 4a51ec7d97743..d2b9a4e6592fb 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs
@@ -846,16 +846,18 @@ private void CheckAccessibility(Location location, BindingDiagnosticBag diagnost
 
         private void CheckModifiers(bool isExplicitInterfaceImplementation, Location location, bool isIndexer, BindingDiagnosticBag diagnostics)
         {
+            Debug.Assert(!IsStatic || (!IsVirtual && !IsOverride)); // Otherwise 'virtual' and 'override' should have been reported and cleared earlier.
+
             bool isExplicitInterfaceImplementationInInterface = isExplicitInterfaceImplementation && ContainingType.IsInterface;
 
             if (this.DeclaredAccessibility == Accessibility.Private && (IsVirtual || (IsAbstract && !isExplicitInterfaceImplementationInInterface) || IsOverride))
             {
                 diagnostics.Add(ErrorCode.ERR_VirtualPrivate, location, this);
             }
-            else if (IsStatic && (IsOverride || IsVirtual || IsAbstract))
+            else if (IsStatic && IsAbstract && !ContainingType.IsInterface)
             {
-                // A static member '{0}' cannot be marked as override, virtual, or abstract
-                diagnostics.Add(ErrorCode.ERR_StaticNotVirtual, location, this);
+                // A static member '{0}' cannot be marked as 'abstract'
+                diagnostics.Add(ErrorCode.ERR_StaticNotVirtual, location, ModifierUtils.ConvertSingleModifierToSyntaxText(DeclarationModifiers.Abstract));
             }
             else if (IsStatic && HasReadOnlyModifier)
             {
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedConversionSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedConversionSymbol.cs
index 937bd94ce0f7a..f5b8502f29705 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedConversionSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedConversionSymbol.cs
@@ -15,6 +15,7 @@ internal sealed class SourceUserDefinedConversionSymbol : SourceUserDefinedOpera
     {
         public static SourceUserDefinedConversionSymbol CreateUserDefinedConversionSymbol(
             SourceMemberContainerTypeSymbol containingType,
+            Binder bodyBinder,
             ConversionOperatorDeclarationSyntax syntax,
             bool isNullableAnalysisEnabled,
             BindingDiagnosticBag diagnostics)
@@ -22,31 +23,41 @@ public static SourceUserDefinedConversionSymbol CreateUserDefinedConversionSymbo
             // Dev11 includes the explicit/implicit keyword, but we don't have a good way to include
             // Narrowing/Widening in VB and we want the languages to be consistent.
             var location = syntax.Type.Location;
-            string name = syntax.ImplicitOrExplicitKeyword.IsKind(SyntaxKind.ImplicitKeyword)
-                ? WellKnownMemberNames.ImplicitConversionName
-                : WellKnownMemberNames.ExplicitConversionName;
+            string name = OperatorFacts.OperatorNameFromDeclaration(syntax);
+
+            var interfaceSpecifier = syntax.ExplicitInterfaceSpecifier;
+
+            TypeSymbol explicitInterfaceType;
+            name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(bodyBinder, interfaceSpecifier, name, diagnostics, out explicitInterfaceType, aliasQualifierOpt: out _);
+
+            var methodKind = interfaceSpecifier == null
+                ? MethodKind.Conversion
+                : MethodKind.ExplicitInterfaceImplementation;
 
             return new SourceUserDefinedConversionSymbol(
-                containingType, name, location, syntax, isNullableAnalysisEnabled, diagnostics);
+                methodKind, containingType, explicitInterfaceType, name, location, syntax, isNullableAnalysisEnabled, diagnostics);
         }
 
         // NOTE: no need to call WithUnsafeRegionIfNecessary, since the signature
         // is bound lazily using binders from a BinderFactory (which will already include an
         // UnsafeBinder, if necessary).
         private SourceUserDefinedConversionSymbol(
+            MethodKind methodKind,
             SourceMemberContainerTypeSymbol containingType,
+            TypeSymbol explicitInterfaceType,
             string name,
             Location location,
             ConversionOperatorDeclarationSyntax syntax,
             bool isNullableAnalysisEnabled,
             BindingDiagnosticBag diagnostics) :
             base(
-                MethodKind.Conversion,
+                methodKind,
+                explicitInterfaceType,
                 name,
                 containingType,
                 location,
                 syntax,
-                MakeDeclarationModifiers(containingType.IsInterface, syntax, location, diagnostics),
+                MakeDeclarationModifiers(methodKind, containingType.IsInterface, syntax, location, diagnostics),
                 hasBody: syntax.HasAnyBody(),
                 isExpressionBodied: syntax.Body == null && syntax.ExpressionBody != null,
                 isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
@@ -60,6 +71,11 @@ private SourceUserDefinedConversionSymbol(
             {
                 diagnostics.Add(ErrorCode.ERR_OvlUnaryOperatorExpected, syntax.ParameterList.GetLocation());
             }
+
+            if (IsStatic && IsAbstract)
+            {
+                CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody: syntax.Body != null || syntax.ExpressionBody != null, diagnostics: diagnostics);
+            }
         }
 
         internal ConversionOperatorDeclarationSyntax GetSyntax()
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedOperatorSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedOperatorSymbol.cs
index 155a67e773e4c..fdea2e0c68c07 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedOperatorSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedOperatorSymbol.cs
@@ -16,6 +16,7 @@ internal sealed class SourceUserDefinedOperatorSymbol : SourceUserDefinedOperato
     {
         public static SourceUserDefinedOperatorSymbol CreateUserDefinedOperatorSymbol(
             SourceMemberContainerTypeSymbol containingType,
+            Binder bodyBinder,
             OperatorDeclarationSyntax syntax,
             bool isNullableAnalysisEnabled,
             BindingDiagnosticBag diagnostics)
@@ -24,27 +25,39 @@ public static SourceUserDefinedOperatorSymbol CreateUserDefinedOperatorSymbol(
 
             string name = OperatorFacts.OperatorNameFromDeclaration(syntax);
 
+            var interfaceSpecifier = syntax.ExplicitInterfaceSpecifier;
+
+            TypeSymbol explicitInterfaceType;
+            name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(bodyBinder, interfaceSpecifier, name, diagnostics, out explicitInterfaceType, aliasQualifierOpt: out _);
+
+            var methodKind = interfaceSpecifier == null
+                ? MethodKind.UserDefinedOperator
+                : MethodKind.ExplicitInterfaceImplementation;
+
             return new SourceUserDefinedOperatorSymbol(
-                containingType, name, location, syntax, isNullableAnalysisEnabled, diagnostics);
+                methodKind, containingType, explicitInterfaceType, name, location, syntax, isNullableAnalysisEnabled, diagnostics);
         }
 
         // NOTE: no need to call WithUnsafeRegionIfNecessary, since the signature
         // is bound lazily using binders from a BinderFactory (which will already include an
         // UnsafeBinder, if necessary).
         private SourceUserDefinedOperatorSymbol(
+            MethodKind methodKind,
             SourceMemberContainerTypeSymbol containingType,
+            TypeSymbol explicitInterfaceType,
             string name,
             Location location,
             OperatorDeclarationSyntax syntax,
             bool isNullableAnalysisEnabled,
             BindingDiagnosticBag diagnostics) :
             base(
-                MethodKind.UserDefinedOperator,
+                methodKind,
+                explicitInterfaceType,
                 name,
                 containingType,
                 location,
                 syntax,
-                MakeDeclarationModifiers(containingType.IsInterface, syntax, location, diagnostics),
+                MakeDeclarationModifiers(methodKind, containingType.IsInterface, syntax, location, diagnostics),
                 hasBody: syntax.HasAnyBody(),
                 isExpressionBodied: syntax.Body == null && syntax.ExpressionBody != null,
                 isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
@@ -54,7 +67,7 @@ private SourceUserDefinedOperatorSymbol(
             CheckForBlockAndExpressionBody(
                 syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
 
-            if (name != WellKnownMemberNames.EqualityOperatorName && name != WellKnownMemberNames.InequalityOperatorName)
+            if (IsAbstract || (name != WellKnownMemberNames.EqualityOperatorName && name != WellKnownMemberNames.InequalityOperatorName))
             {
                 CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody: syntax.Body != null || syntax.ExpressionBody != null, diagnostics: diagnostics);
             }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedOperatorSymbolBase.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedOperatorSymbolBase.cs
index 45068883ccef4..09581a5bd0373 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedOperatorSymbolBase.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedOperatorSymbolBase.cs
@@ -8,19 +8,23 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
-    internal abstract class SourceUserDefinedOperatorSymbolBase : SourceMemberMethodSymbol
+    internal abstract class SourceUserDefinedOperatorSymbolBase : SourceOrdinaryMethodOrUserDefinedOperatorSymbol
     {
+        // tomat: ignoreDynamic should be true, but we don't want to introduce breaking change. See bug 605326.
         private const TypeCompareKind ComparisonForUserDefinedOperators = TypeCompareKind.IgnoreTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes;
         private readonly string _name;
         private readonly bool _isExpressionBodied;
-        private ImmutableArray<ParameterSymbol> _lazyParameters;
-        private TypeWithAnnotations _lazyReturnType;
+#nullable enable
+        private readonly TypeSymbol? _explicitInterfaceType;
+#nullable disable
 
         protected SourceUserDefinedOperatorSymbolBase(
             MethodKind methodKind,
+            TypeSymbol explicitInterfaceType,
             string name,
             SourceMemberContainerTypeSymbol containingType,
             Location location,
@@ -33,6 +37,7 @@ protected SourceUserDefinedOperatorSymbolBase(
             BindingDiagnosticBag diagnostics) :
             base(containingType, syntax.GetReference(), location, isIterator: isIterator)
         {
+            _explicitInterfaceType = explicitInterfaceType;
             _name = name;
             _isExpressionBodied = isExpressionBodied;
 
@@ -45,9 +50,9 @@ protected SourceUserDefinedOperatorSymbolBase(
             this.MakeFlags(methodKind, declarationModifiers, returnsVoid: false, isExtensionMethod: false, isNullableAnalysisEnabled: isNullableAnalysisEnabled);
 
             if (this.ContainingType.IsInterface &&
-                (methodKind == MethodKind.Conversion || name == WellKnownMemberNames.EqualityOperatorName || name == WellKnownMemberNames.InequalityOperatorName))
+                !IsAbstract && (methodKind == MethodKind.Conversion || name == WellKnownMemberNames.EqualityOperatorName || name == WellKnownMemberNames.InequalityOperatorName))
             {
-                // If we have a conversion or equality/inequality operator in an interface, we already have reported that fact as 
+                // If we have an unsupported conversion or equality/inequality operator in an interface, we already have reported that fact as 
                 // an error. No need to cascade the error further.
                 return;
             }
@@ -63,7 +68,14 @@ protected SourceUserDefinedOperatorSymbolBase(
 
             // SPEC: An operator declaration must include both a public and a
             // SPEC: static modifier
-            if (this.DeclaredAccessibility != Accessibility.Public || !this.IsStatic)
+            if (this.IsExplicitInterfaceImplementation)
+            {
+                if (!this.IsStatic)
+                {
+                    diagnostics.Add(ErrorCode.ERR_ExplicitImplementationOfOperatorsMustBeStatic, this.Locations[0], this);
+                }
+            }
+            else if (this.DeclaredAccessibility != Accessibility.Public || !this.IsStatic)
             {
                 // CS0558: User-defined operator '...' must be declared static and public
                 diagnostics.Add(ErrorCode.ERR_OperatorsMustBeStatic, this.Locations[0], this);
@@ -73,9 +85,21 @@ protected SourceUserDefinedOperatorSymbolBase(
             // SPEC: its operator body consists of a semicolon. For expression-bodied
             // SPEC: operators, the body is an expression. For all other operators,
             // SPEC: the operator body consists of a block...
-            if (hasBody && IsExtern)
+            if (IsAbstract && IsExtern)
+            {
+                diagnostics.Add(ErrorCode.ERR_AbstractAndExtern, location, this);
+            }
+            else if (hasBody && (IsExtern || IsAbstract))
             {
-                diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
+                Debug.Assert(!(IsAbstract && IsExtern));
+                if (IsExtern)
+                {
+                    diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
+                }
+                else
+                {
+                    diagnostics.Add(ErrorCode.ERR_AbstractHasBody, location, this);
+                }
             }
             else if (!hasBody && !IsExtern && !IsAbstract && !IsPartial)
             {
@@ -94,20 +118,76 @@ protected SourceUserDefinedOperatorSymbolBase(
             }
         }
 
-        protected static DeclarationModifiers MakeDeclarationModifiers(bool inInterface, BaseMethodDeclarationSyntax syntax, Location location, BindingDiagnosticBag diagnostics)
+        protected static DeclarationModifiers MakeDeclarationModifiers(MethodKind methodKind, bool inInterface, BaseMethodDeclarationSyntax syntax, Location location, BindingDiagnosticBag diagnostics)
         {
-            var defaultAccess = inInterface ? DeclarationModifiers.Public : DeclarationModifiers.Private;
+            bool isExplicitInterfaceImplementation = methodKind == MethodKind.ExplicitInterfaceImplementation;
+            var defaultAccess = inInterface && !isExplicitInterfaceImplementation ? DeclarationModifiers.Public : DeclarationModifiers.Private;
             var allowedModifiers =
-                DeclarationModifiers.AccessibilityMask |
                 DeclarationModifiers.Static |
                 DeclarationModifiers.Extern |
                 DeclarationModifiers.Unsafe;
 
-            return ModifierUtils.MakeAndCheckNontypeMemberModifiers(
+            if (!isExplicitInterfaceImplementation)
+            {
+                allowedModifiers |= DeclarationModifiers.AccessibilityMask;
+
+                if (inInterface)
+                {
+                    allowedModifiers |= DeclarationModifiers.Abstract;
+
+                    if (syntax is OperatorDeclarationSyntax { OperatorToken: var opToken } && opToken.Kind() is not (SyntaxKind.EqualsEqualsToken or SyntaxKind.ExclamationEqualsToken))
+                    {
+                        allowedModifiers |= DeclarationModifiers.Sealed;
+                    }
+                }
+            }
+
+            var result = ModifierUtils.MakeAndCheckNontypeMemberModifiers(
                 syntax.Modifiers, defaultAccess, allowedModifiers, location, diagnostics, modifierErrors: out _);
-        }
 
-        protected abstract Location ReturnTypeLocation { get; }
+            if (inInterface)
+            {
+                if ((result & (DeclarationModifiers.Abstract | DeclarationModifiers.Sealed)) != 0)
+                {
+                    if ((result & (DeclarationModifiers.Sealed | DeclarationModifiers.Abstract)) == (DeclarationModifiers.Sealed | DeclarationModifiers.Abstract))
+                    {
+                        diagnostics.Add(ErrorCode.ERR_BadMemberFlag, location, ModifierUtils.ConvertSingleModifierToSyntaxText(DeclarationModifiers.Sealed));
+                        result &= ~DeclarationModifiers.Sealed;
+                    }
+
+                    LanguageVersion availableVersion = ((CSharpParseOptions)location.SourceTree.Options).LanguageVersion;
+                    LanguageVersion requiredVersion = MessageID.IDS_FeatureStaticAbstractMembersInInterfaces.RequiredVersion();
+
+                    if (availableVersion < requiredVersion)
+                    {
+                        var requiredVersionArgument = new CSharpRequiredLanguageVersion(requiredVersion);
+                        var availableVersionArgument = availableVersion.ToDisplayString();
+
+                        reportModifierIfPresent(result, DeclarationModifiers.Abstract, location, diagnostics, requiredVersionArgument, availableVersionArgument);
+                        reportModifierIfPresent(result, DeclarationModifiers.Sealed, location, diagnostics, requiredVersionArgument, availableVersionArgument);
+                    }
+
+                    result &= ~DeclarationModifiers.Sealed;
+                }
+                else if ((result & DeclarationModifiers.Static) != 0 && syntax is OperatorDeclarationSyntax { OperatorToken: var opToken } && opToken.Kind() is not (SyntaxKind.EqualsEqualsToken or SyntaxKind.ExclamationEqualsToken))
+                {
+                    Binder.CheckFeatureAvailability(location.SourceTree, MessageID.IDS_DefaultInterfaceImplementation, diagnostics, location);
+                }
+            }
+
+            return result;
+
+            static void reportModifierIfPresent(DeclarationModifiers result, DeclarationModifiers errorModifier, Location location, BindingDiagnosticBag diagnostics, CSharpRequiredLanguageVersion requiredVersionArgument, string availableVersionArgument)
+            {
+                if ((result & errorModifier) != 0)
+                {
+                    diagnostics.Add(ErrorCode.ERR_InvalidModifierForLanguageVersion, location,
+                                    ModifierUtils.ConvertSingleModifierToSyntaxText(errorModifier),
+                                    availableVersionArgument,
+                                    requiredVersionArgument);
+                }
+            }
+        }
 
         protected (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BaseMethodDeclarationSyntax declarationSyntax, TypeSyntax returnTypeSyntax, BindingDiagnosticBag diagnostics)
         {
@@ -165,29 +245,60 @@ protected static DeclarationModifiers MakeDeclarationModifiers(bool inInterface,
 
         protected override void MethodChecks(BindingDiagnosticBag diagnostics)
         {
-            (_lazyReturnType, _lazyParameters) = MakeParametersAndBindReturnType(diagnostics);
+            var (returnType, parameters) = MakeParametersAndBindReturnType(diagnostics);
 
-            this.SetReturnsVoid(_lazyReturnType.IsVoidType());
+            MethodChecks(returnType, parameters, diagnostics);
 
-            // If we have a conversion/equality/inequality operator in an interface or static class then we already 
+            // If we have a static class then we already 
             // have reported that fact as an error. No need to cascade the error further.
-            if ((this.ContainingType.IsInterfaceType() &&
-                (MethodKind == MethodKind.Conversion || Name == WellKnownMemberNames.EqualityOperatorName || Name == WellKnownMemberNames.InequalityOperatorName)) ||
-                this.ContainingType.IsStatic)
+            if (this.ContainingType.IsStatic)
             {
                 return;
             }
 
-            // SPEC: All types referenced in an operator declaration must be at least as accessible 
-            // SPEC: as the operator itself.
-
-            CheckEffectiveAccessibility(_lazyReturnType, _lazyParameters, diagnostics);
             CheckValueParameters(diagnostics);
             CheckOperatorSignatures(diagnostics);
         }
 
         protected abstract (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics);
 
+        protected sealed override void ExtensionMethodChecks(BindingDiagnosticBag diagnostics)
+        {
+        }
+
+        protected sealed override MethodSymbol FindExplicitlyImplementedMethod(BindingDiagnosticBag diagnostics)
+        {
+            if (_explicitInterfaceType is object)
+            {
+                string interfaceMethodName;
+                ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier;
+
+                switch (syntaxReferenceOpt.GetSyntax())
+                {
+                    case OperatorDeclarationSyntax operatorDeclaration:
+                        interfaceMethodName = OperatorFacts.OperatorNameFromDeclaration(operatorDeclaration);
+                        explicitInterfaceSpecifier = operatorDeclaration.ExplicitInterfaceSpecifier;
+                        break;
+
+                    case ConversionOperatorDeclarationSyntax conversionDeclaration:
+                        interfaceMethodName = OperatorFacts.OperatorNameFromDeclaration(conversionDeclaration);
+                        explicitInterfaceSpecifier = conversionDeclaration.ExplicitInterfaceSpecifier;
+                        break;
+
+                    default:
+                        throw ExceptionUtilities.Unreachable;
+                }
+
+                return this.FindExplicitlyImplementedMethod(isOperator: true, _explicitInterfaceType, interfaceMethodName, explicitInterfaceSpecifier, diagnostics);
+            }
+
+            return null;
+        }
+
+#nullable enable
+        protected sealed override TypeSymbol? ExplicitInterfaceType => _explicitInterfaceType;
+#nullable disable
+
         private void CheckValueParameters(BindingDiagnosticBag diagnostics)
         {
             // SPEC: The parameters of an operator must be value parameters.
@@ -203,6 +314,12 @@ private void CheckValueParameters(BindingDiagnosticBag diagnostics)
 
         private void CheckOperatorSignatures(BindingDiagnosticBag diagnostics)
         {
+            if (MethodKind == MethodKind.ExplicitInterfaceImplementation)
+            {
+                // The signature is driven by the interface
+                return;
+            }
+
             // Have we even got the right formal parameter arity? If not then 
             // we are in an error recovery scenario and we should just bail 
             // out immediately.
@@ -305,7 +422,7 @@ private void CheckUserDefinedConversionSignature(BindingDiagnosticBag diagnostic
                 !MatchesContainingType(target))
             {
                 // CS0556: User-defined conversion must convert to or from the enclosing type
-                diagnostics.Add(ErrorCode.ERR_ConversionNotInvolvingContainedType, this.Locations[0]);
+                diagnostics.Add(IsAbstract ? ErrorCode.ERR_AbstractConversionNotInvolvingContainedType : ErrorCode.ERR_ConversionNotInvolvingContainedType, this.Locations[0]);
                 return;
             }
 
@@ -315,8 +432,7 @@ private void CheckUserDefinedConversionSignature(BindingDiagnosticBag diagnostic
                     ? source.Equals(target, ComparisonForUserDefinedOperators)
                     : source0.Equals(target0, ComparisonForUserDefinedOperators))
             {
-                // CS0555: User-defined operator cannot take an object of the enclosing type 
-                // and convert to an object of the enclosing type
+                // CS0555: User-defined operator cannot convert a type to itself
                 diagnostics.Add(ErrorCode.ERR_IdentityConversion, this.Locations[0]);
                 return;
             }
@@ -403,22 +519,19 @@ private void CheckUserDefinedConversionSignature(BindingDiagnosticBag diagnostic
                 different = source;
             }
 
-            if (different.IsClassType())
+            if (different.IsClassType() && !same.IsTypeParameter())
             {
                 // different is a class type:
                 Debug.Assert(!different.IsTypeParameter());
 
-                // "same" is the containing class, so it can't be a type parameter
-                Debug.Assert(!same.IsTypeParameter());
-
                 var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);
 
-                if (same.IsDerivedFrom(different, ComparisonForUserDefinedOperators, useSiteInfo: ref useSiteInfo)) // tomat: ignoreDynamic should be true, but we don't want to introduce breaking change. See bug 605326.
+                if (same.IsDerivedFrom(different, ComparisonForUserDefinedOperators, useSiteInfo: ref useSiteInfo))
                 {
                     // '{0}': user-defined conversions to or from a base type are not allowed
                     diagnostics.Add(ErrorCode.ERR_ConversionWithBase, this.Locations[0], this);
                 }
-                else if (different.IsDerivedFrom(same, ComparisonForUserDefinedOperators, useSiteInfo: ref useSiteInfo)) // tomat: ignoreDynamic should be true, but we don't want to introduce breaking change. See bug 605326.
+                else if (different.IsDerivedFrom(same, ComparisonForUserDefinedOperators, useSiteInfo: ref useSiteInfo))
                 {
                     // '{0}': user-defined conversions to or from a derived type are not allowed
                     diagnostics.Add(ErrorCode.ERR_ConversionWithDerived, this.Locations[0], this);
@@ -436,7 +549,7 @@ private void CheckUnarySignature(BindingDiagnosticBag diagnostics)
             if (!MatchesContainingType(this.GetParameterType(0).StrippedType()))
             {
                 // The parameter of a unary operator must be the containing type
-                diagnostics.Add(ErrorCode.ERR_BadUnaryOperatorSignature, this.Locations[0]);
+                diagnostics.Add(IsAbstract ? ErrorCode.ERR_BadAbstractUnaryOperatorSignature : ErrorCode.ERR_BadUnaryOperatorSignature, this.Locations[0]);
             }
 
             if (this.ReturnsVoid)
@@ -461,7 +574,7 @@ private void CheckTrueFalseSignature(BindingDiagnosticBag diagnostics)
             if (!MatchesContainingType(this.GetParameterType(0).StrippedType()))
             {
                 // The parameter of a unary operator must be the containing type
-                diagnostics.Add(ErrorCode.ERR_BadUnaryOperatorSignature, this.Locations[0]);
+                diagnostics.Add(IsAbstract ? ErrorCode.ERR_BadAbstractUnaryOperatorSignature : ErrorCode.ERR_BadUnaryOperatorSignature, this.Locations[0]);
             }
         }
 
@@ -511,23 +624,47 @@ private void CheckIncrementDecrementSignature(BindingDiagnosticBag diagnostics)
             if (!MatchesContainingType(parameterType.StrippedType()))
             {
                 // CS0559: The parameter type for ++ or -- operator must be the containing type
-                diagnostics.Add(ErrorCode.ERR_BadIncDecSignature, this.Locations[0]);
+                diagnostics.Add(IsAbstract ? ErrorCode.ERR_BadAbstractIncDecSignature : ErrorCode.ERR_BadIncDecSignature, this.Locations[0]);
             }
-            else if (!this.ReturnType.EffectiveTypeNoUseSiteDiagnostics.IsEqualToOrDerivedFrom(parameterType, ComparisonForUserDefinedOperators, useSiteInfo: ref useSiteInfo))
+            else if (!(parameterType.IsTypeParameter() ?
+                         this.ReturnType.Equals(parameterType, ComparisonForUserDefinedOperators) :
+                         ((IsAbstract && IsContainingType(parameterType) && IsSelfConstrainedTypeParameter(this.ReturnType)) ||
+                             this.ReturnType.EffectiveTypeNoUseSiteDiagnostics.IsEqualToOrDerivedFrom(parameterType, ComparisonForUserDefinedOperators, useSiteInfo: ref useSiteInfo))))
             {
                 // CS0448: The return type for ++ or -- operator must match the parameter type
                 //         or be derived from the parameter type
-                diagnostics.Add(ErrorCode.ERR_BadIncDecRetType, this.Locations[0]);
+                diagnostics.Add(IsAbstract ? ErrorCode.ERR_BadAbstractIncDecRetType : ErrorCode.ERR_BadIncDecRetType, this.Locations[0]);
             }
 
             diagnostics.Add(this.Locations[0], useSiteInfo);
         }
 
         private bool MatchesContainingType(TypeSymbol type)
+        {
+            return IsContainingType(type) || (IsAbstract && IsSelfConstrainedTypeParameter(type));
+        }
+
+        private bool IsContainingType(TypeSymbol type)
         {
             return type.Equals(this.ContainingType, ComparisonForUserDefinedOperators);
         }
 
+        public static bool IsSelfConstrainedTypeParameter(TypeSymbol type, NamedTypeSymbol containingType)
+        {
+            Debug.Assert(containingType.IsDefinition);
+            return type is TypeParameterSymbol p &&
+                // https://github.com/dotnet/roslyn/issues/53801: For now assuming the type parameter must belong to the containing type.
+                (object)p.ContainingSymbol == containingType &&
+                // https://github.com/dotnet/roslyn/issues/53801: For now assume containing type must be one of the directly specified constraints.
+                p.ConstraintTypesNoUseSiteDiagnostics.Any((typeArgument, containingType) => typeArgument.Type.Equals(containingType, ComparisonForUserDefinedOperators),
+                                                          containingType);
+        }
+
+        private bool IsSelfConstrainedTypeParameter(TypeSymbol type)
+        {
+            return IsSelfConstrainedTypeParameter(type, this.ContainingType);
+        }
+
         private void CheckShiftSignature(BindingDiagnosticBag diagnostics)
         {
             // SPEC: A binary << or >> operator must take two parameters, the first
@@ -540,7 +677,7 @@ private void CheckShiftSignature(BindingDiagnosticBag diagnostics)
                 // CS0546: The first operand of an overloaded shift operator must have the 
                 //         same type as the containing type, and the type of the second 
                 //         operand must be int
-                diagnostics.Add(ErrorCode.ERR_BadShiftOperatorSignature, this.Locations[0]);
+                diagnostics.Add(IsAbstract ? ErrorCode.ERR_BadAbstractShiftOperatorSignature : ErrorCode.ERR_BadShiftOperatorSignature, this.Locations[0]);
             }
 
             if (this.ReturnsVoid)
@@ -559,7 +696,7 @@ private void CheckBinarySignature(BindingDiagnosticBag diagnostics)
                 !MatchesContainingType(this.GetParameterType(1).StrippedType()))
             {
                 // CS0563: One of the parameters of a binary operator must be the containing type
-                diagnostics.Add(ErrorCode.ERR_BadBinaryOperatorSignature, this.Locations[0]);
+                diagnostics.Add(IsAbstract ? ErrorCode.ERR_BadAbstractBinaryOperatorSignature : ErrorCode.ERR_BadBinaryOperatorSignature, this.Locations[0]);
             }
 
             if (this.ReturnsVoid)
@@ -578,15 +715,6 @@ public sealed override string Name
             }
         }
 
-        public sealed override bool ReturnsVoid
-        {
-            get
-            {
-                LazyMethodChecks();
-                return base.ReturnsVoid;
-            }
-        }
-
         public sealed override bool IsVararg
         {
             get
@@ -611,32 +739,6 @@ public sealed override ImmutableArray<Location> Locations
             }
         }
 
-        internal sealed override int ParameterCount
-        {
-            get
-            {
-                if (!_lazyParameters.IsDefault)
-                {
-                    int result = _lazyParameters.Length;
-                    Debug.Assert(result == GetParameterCountFromSyntax());
-                    return result;
-                }
-
-                return GetParameterCountFromSyntax();
-            }
-        }
-
-        protected abstract int GetParameterCountFromSyntax();
-
-        public sealed override ImmutableArray<ParameterSymbol> Parameters
-        {
-            get
-            {
-                LazyMethodChecks();
-                return _lazyParameters;
-            }
-        }
-
         public sealed override ImmutableArray<TypeParameterSymbol> TypeParameters
         {
             get { return ImmutableArray<TypeParameterSymbol>.Empty; }
@@ -653,51 +755,39 @@ public sealed override RefKind RefKind
             get { return RefKind.None; }
         }
 
-        public sealed override TypeWithAnnotations ReturnTypeWithAnnotations
-        {
-            get
-            {
-                LazyMethodChecks();
-                return _lazyReturnType;
-            }
-        }
-
         internal sealed override bool IsExpressionBodied
         {
             get { return _isExpressionBodied; }
         }
 
-        internal sealed override void AfterAddingTypeMembersChecks(ConversionsBase conversions, BindingDiagnosticBag diagnostics)
+        protected sealed override void CheckConstraintsForExplicitInterfaceType(ConversionsBase conversions, BindingDiagnosticBag diagnostics)
         {
-            // Check constraints on return type and parameters. Note: Dev10 uses the
-            // method name location for any such errors. We'll do the same for return
-            // type errors but for parameter errors, we'll use the parameter location.
-
-            var compilation = DeclaringCompilation;
-
-            this.ReturnType.CheckAllConstraints(compilation, conversions, this.Locations[0], diagnostics);
-
-            foreach (var parameter in this.Parameters)
+            if ((object)_explicitInterfaceType != null)
             {
-                parameter.Type.CheckAllConstraints(compilation, conversions, parameter.Locations[0], diagnostics);
-            }
+                NameSyntax name;
 
-            ParameterHelpers.EnsureIsReadOnlyAttributeExists(compilation, Parameters, diagnostics, modifyCompilation: true);
-
-            if (ReturnType.ContainsNativeInteger())
-            {
-                compilation.EnsureNativeIntegerAttributeExists(diagnostics, ReturnTypeLocation, modifyCompilation: true);
-            }
-
-            ParameterHelpers.EnsureNativeIntegerAttributeExists(compilation, Parameters, diagnostics, modifyCompilation: true);
+                switch (syntaxReferenceOpt.GetSyntax())
+                {
+                    case OperatorDeclarationSyntax operatorDeclaration:
+                        Debug.Assert(operatorDeclaration.ExplicitInterfaceSpecifier != null);
+                        name = operatorDeclaration.ExplicitInterfaceSpecifier.Name;
+                        break;
+
+                    case ConversionOperatorDeclarationSyntax conversionDeclaration:
+                        Debug.Assert(conversionDeclaration.ExplicitInterfaceSpecifier != null);
+                        name = conversionDeclaration.ExplicitInterfaceSpecifier.Name;
+                        break;
+
+                    default:
+                        throw ExceptionUtilities.Unreachable;
+                }
 
-            if (compilation.ShouldEmitNullableAttributes(this) &&
-                ReturnTypeWithAnnotations.NeedsNullableAttribute())
-            {
-                compilation.EnsureNullableAttributeExists(diagnostics, ReturnTypeLocation, modifyCompilation: true);
+                _explicitInterfaceType.CheckAllConstraints(DeclaringCompilation, conversions, new SourceLocation(name), diagnostics);
             }
+        }
 
-            ParameterHelpers.EnsureNullableAttributeExists(compilation, this, Parameters, diagnostics, modifyCompilation: true);
+        protected sealed override void PartialMethodChecks(BindingDiagnosticBag diagnostics)
+        {
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/SubstitutedMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SubstitutedMethodSymbol.cs
index ffbb3ca75a716..de2b9d597ad0a 100644
--- a/src/Compilers/CSharp/Portable/Symbols/SubstitutedMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/SubstitutedMethodSymbol.cs
@@ -252,7 +252,7 @@ public sealed override ImmutableArray<ParameterSymbol> Parameters
             {
                 if (_lazyParameters.IsDefault)
                 {
-                    ImmutableInterlocked.InterlockedCompareExchange(ref _lazyParameters, SubstituteParameters(), default(ImmutableArray<ParameterSymbol>));
+                    ImmutableInterlocked.InterlockedInitialize(ref _lazyParameters, SubstituteParameters());
                 }
 
                 return _lazyParameters;
diff --git a/src/Compilers/CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs
index 303d57ab4acd9..4aa24cfded6a7 100644
--- a/src/Compilers/CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs
@@ -318,6 +318,23 @@ void cacheResult(ImmutableArray<Symbol> result)
             }
         }
 
+#nullable enable
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            if (_unbound)
+            {
+                yield break;
+            }
+
+            foreach ((MethodSymbol body, MethodSymbol implemented) in OriginalDefinition.SynthesizedInterfaceMethodImpls())
+            {
+                var newBody = ExplicitInterfaceHelpers.SubstituteExplicitInterfaceImplementation(body, this.TypeSubstitution);
+                var newImplemented = ExplicitInterfaceHelpers.SubstituteExplicitInterfaceImplementation(implemented, this.TypeSubstitution);
+                yield return (newBody, newImplemented);
+            }
+        }
+#nullable disable
+
         internal override IEnumerable<FieldSymbol> GetFieldsToEmit()
         {
             throw ExceptionUtilities.Unreachable;
diff --git a/src/Compilers/CSharp/Portable/Symbols/SymbolExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/SymbolExtensions.cs
index b9fcdc08b673e..7a27991ad8521 100644
--- a/src/Compilers/CSharp/Portable/Symbols/SymbolExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/SymbolExtensions.cs
@@ -531,7 +531,7 @@ internal static void GetTypeOrReturnType(this Symbol symbol, out RefKind refKind
 
         internal static bool IsImplementableInterfaceMember(this Symbol symbol)
         {
-            return !symbol.IsStatic && !symbol.IsSealed && (symbol.IsAbstract || symbol.IsVirtual) && (symbol.ContainingType?.IsInterface ?? false);
+            return !symbol.IsSealed && (symbol.IsAbstract || symbol.IsVirtual) && (symbol.ContainingType?.IsInterface ?? false);
         }
 
         internal static bool RequiresInstanceReceiver(this Symbol symbol)
@@ -815,5 +815,29 @@ internal static ImmutableArray<INamespaceSymbol> GetPublicSymbols(this Immutable
         {
             return symbol.GetSymbol<FunctionPointerTypeSymbol>();
         }
+
+        /// <summary>
+        /// Returns true if the method has a [AsyncMethodBuilder(typeof(B))] attribute. If so it returns type B.
+        /// Validation of builder type B is left for elsewhere. This method returns B without validation of any kind.
+        /// </summary>
+        internal static bool HasAsyncMethodBuilderAttribute(this Symbol symbol, [NotNullWhen(true)] out object? builderArgument)
+        {
+            Debug.Assert(symbol is not null);
+
+            // Find the AsyncMethodBuilder attribute.
+            foreach (var attr in symbol.GetAttributes())
+            {
+                if (attr.IsTargetAttribute(symbol, AttributeDescription.AsyncMethodBuilderAttribute)
+                    && attr.CommonConstructorArguments.Length == 1
+                    && attr.CommonConstructorArguments[0].Kind == TypedConstantKind.Type)
+                {
+                    builderArgument = attr.CommonConstructorArguments[0].ValueInternal!;
+                    return true;
+                }
+            }
+
+            builderArgument = null;
+            return false;
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordEqualityOperatorBase.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordEqualityOperatorBase.cs
index 22587d4cbd5db..a85df5e9f7b81 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordEqualityOperatorBase.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordEqualityOperatorBase.cs
@@ -34,7 +34,7 @@ internal abstract class SynthesizedRecordEqualityOperatorBase : SourceUserDefine
         private readonly int _memberOffset;
 
         protected SynthesizedRecordEqualityOperatorBase(SourceMemberContainerTypeSymbol containingType, string name, int memberOffset, BindingDiagnosticBag diagnostics)
-            : base(MethodKind.UserDefinedOperator, name, containingType, containingType.Locations[0], (CSharpSyntaxNode)containingType.SyntaxReferences[0].GetSyntax(),
+            : base(MethodKind.UserDefinedOperator, explicitInterfaceType: null, name, containingType, containingType.Locations[0], (CSharpSyntaxNode)containingType.SyntaxReferences[0].GetSyntax(),
                    DeclarationModifiers.Public | DeclarationModifiers.Static, hasBody: true, isExpressionBodied: false, isIterator: false, isNullableAnalysisEnabled: false, diagnostics)
         {
             Debug.Assert(name == WellKnownMemberNames.EqualityOperatorName || name == WellKnownMemberNames.InequalityOperatorName);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs
index 751d8b543a9be..49c32f1f43a57 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs
@@ -223,5 +223,10 @@ internal override IEnumerable<FieldSymbol> GetFieldsToEmit()
         internal sealed override NamedTypeSymbol AsNativeInteger() => throw ExceptionUtilities.Unreachable;
 
         internal sealed override NamedTypeSymbol NativeIntegerUnderlyingType => null;
+
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedDelegateSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedDelegateSymbol.cs
index 6a428d3b1d7cf..c91d8f3f3136c 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedDelegateSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedDelegateSymbol.cs
@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
@@ -125,16 +126,17 @@ internal InvokeMethod(SynthesizedDelegateSymbol containingType, BitVector byRefP
                 // if we are given Void type the method returns Void, otherwise its return type is the last type parameter of the delegate:
                 _returnType = voidReturnTypeOpt ?? typeParams.Last();
 
-                var parameters = new ParameterSymbol[typeParams.Length - ((object)voidReturnTypeOpt != null ? 0 : 1)];
-                for (int i = 0; i < parameters.Length; i++)
+                int parameterCount = typeParams.Length - ((object)voidReturnTypeOpt != null ? 0 : 1);
+                var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(parameterCount);
+                for (int i = 0; i < parameterCount; i++)
                 {
                     // we don't need to distinguish between out and ref since this is an internal synthesized symbol:
                     var refKind = !byRefParameters.IsNull && byRefParameters[i] ? RefKind.Ref : RefKind.None;
 
-                    parameters[i] = SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(typeParams[i]), i, refKind);
+                    parameters.Add(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(typeParams[i]), i, refKind));
                 }
 
-                _parameters = parameters.AsImmutableOrNull();
+                _parameters = parameters.ToImmutableAndFree();
             }
 
             public override string Name
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEmbeddedAttributeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEmbeddedAttributeSymbol.cs
index a175cddcb2cd6..91fdaa6613923 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEmbeddedAttributeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEmbeddedAttributeSymbol.cs
@@ -181,6 +181,11 @@ internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, r
         internal sealed override NamedTypeSymbol AsNativeInteger() => throw ExceptionUtilities.Unreachable;
 
         internal sealed override NamedTypeSymbol NativeIntegerUnderlyingType => null;
+
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
     }
 
     /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedExplicitImplementationForwardingMethod.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedExplicitImplementationForwardingMethod.cs
index 26508df4bfce7..58a2f15cc2eae 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedExplicitImplementationForwardingMethod.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedExplicitImplementationForwardingMethod.cs
@@ -44,5 +44,11 @@ public override MethodKind MethodKind
                     MethodKind.ExplicitInterfaceImplementation;
             }
         }
+
+        public override bool IsStatic => _implementingMethod.IsStatic;
+
+        internal override bool HasSpecialName => false;
+
+        internal sealed override bool HasRuntimeSpecialName => false;
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedGlobalMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedGlobalMethodSymbol.cs
index 8f7155d60dadd..4b66d9d66ebfe 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedGlobalMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedGlobalMethodSymbol.cs
@@ -167,7 +167,8 @@ public override ImmutableArray<ParameterSymbol> Parameters
         {
             get
             {
-                if (_parameters.IsEmpty)
+                Debug.Assert(!_parameters.IsDefault, $"Expected {nameof(SetParameters)} prior to accessing this property.");
+                if (_parameters.IsDefault)
                 {
                     return ImmutableArray<ParameterSymbol>.Empty;
                 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedImplementationMethod.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedImplementationMethod.cs
index 9a4f8d20f6921..23fe785515aa3 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedImplementationMethod.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedImplementationMethod.cs
@@ -208,7 +208,7 @@ public override string Name
             get { return _name; }
         }
 
-        internal sealed override bool HasSpecialName
+        internal override bool HasSpecialName
         {
             get { return _interfaceMethod.HasSpecialName; }
         }
@@ -225,20 +225,20 @@ internal sealed override bool RequiresSecurityObject
 
         internal sealed override bool IsMetadataVirtual(bool ignoreInterfaceImplementationChanges = false)
         {
-            return true;
+            return !IsStatic;
         }
 
         internal override bool IsMetadataFinal
         {
             get
             {
-                return true;
+                return !IsStatic;
             }
         }
 
         internal sealed override bool IsMetadataNewSlot(bool ignoreInterfaceImplementationChanges = false)
         {
-            return true;
+            return !IsStatic;
         }
 
         public override DllImportData GetDllImportData()
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedIntrinsicOperatorSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedIntrinsicOperatorSymbol.cs
index e97ac78ab7771..047fcb25a065d 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedIntrinsicOperatorSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedIntrinsicOperatorSymbol.cs
@@ -42,8 +42,8 @@ public SynthesizedIntrinsicOperatorSymbol(TypeSymbol leftType, string name, Type
             Debug.Assert((leftType.IsDynamic() || rightType.IsDynamic()) == returnType.IsDynamic());
             Debug.Assert(_containingType.IsDynamic() == returnType.IsDynamic());
 
-            _parameters = (new ParameterSymbol[] {new SynthesizedOperatorParameterSymbol(this, leftType, 0, "left"),
-                                                      new SynthesizedOperatorParameterSymbol(this, rightType, 1, "right")}).AsImmutableOrNull();
+            _parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedOperatorParameterSymbol(this, leftType, 0, "left"),
+                                                      new SynthesizedOperatorParameterSymbol(this, rightType, 1, "right"));
             _isCheckedBuiltin = isCheckedBuiltin;
         }
 
@@ -52,7 +52,7 @@ public SynthesizedIntrinsicOperatorSymbol(TypeSymbol container, string name, Typ
             _containingType = container;
             _name = name;
             _returnType = returnType;
-            _parameters = (new ParameterSymbol[] { new SynthesizedOperatorParameterSymbol(this, container, 0, "value") }).AsImmutableOrNull();
+            _parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedOperatorParameterSymbol(this, container, 0, "value"));
             _isCheckedBuiltin = isCheckedBuiltin;
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedSubstitutedTypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedSubstitutedTypeParameterSymbol.cs
index fc8221d9ad1f4..56979139e7487 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedSubstitutedTypeParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedSubstitutedTypeParameterSymbol.cs
@@ -5,6 +5,7 @@
 #nullable disable
 
 using System.Collections.Immutable;
+using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 
@@ -18,6 +19,10 @@ internal sealed class SynthesizedSubstitutedTypeParameterSymbol : SubstitutedTyp
         public SynthesizedSubstitutedTypeParameterSymbol(Symbol owner, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal)
             : base(owner, map, substitutedFrom, ordinal)
         {
+            Debug.Assert(this.TypeParameterKind == (ContainingSymbol is MethodSymbol ? TypeParameterKind.Method :
+                                                   (ContainingSymbol is NamedTypeSymbol ? TypeParameterKind.Type :
+                                                   TypeParameterKind.Cref)),
+                         $"Container is {ContainingSymbol?.Kind}, TypeParameterKind is {this.TypeParameterKind}");
         }
 
         public override bool IsImplicitlyDeclared
@@ -25,6 +30,8 @@ public override bool IsImplicitlyDeclared
             get { return true; }
         }
 
+        public override TypeParameterKind TypeParameterKind => ContainingSymbol is MethodSymbol ? TypeParameterKind.Method : TypeParameterKind.Type;
+
         internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<SynthesizedAttributeData> attributes)
         {
             base.AddSynthesizedAttributes(moduleBuilder, ref attributes);
diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/TypeParameterSymbol.cs
index f492c1ca1b57a..f2b2ea25a8e1d 100644
--- a/src/Compilers/CSharp/Portable/Symbols/TypeParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/TypeParameterSymbol.cs
@@ -694,5 +694,10 @@ protected sealed override ITypeSymbol CreateITypeSymbol(CodeAnalysis.NullableAnn
         internal override bool IsRecord => false;
 
         internal override bool IsRecordStruct => false;
+
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeSymbol.SymbolAndDiagnostics.cs b/src/Compilers/CSharp/Portable/Symbols/TypeSymbol.SymbolAndDiagnostics.cs
index 2c8d61d9b514e..19b3986bcb69a 100644
--- a/src/Compilers/CSharp/Portable/Symbols/TypeSymbol.SymbolAndDiagnostics.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/TypeSymbol.SymbolAndDiagnostics.cs
@@ -16,7 +16,7 @@ internal partial class TypeSymbol
         /// Represents the method by which this type implements a given interface type
         /// and/or the corresponding diagnostics.
         /// </summary>
-        protected class SymbolAndDiagnostics
+        internal class SymbolAndDiagnostics
         {
             public static readonly SymbolAndDiagnostics Empty = new SymbolAndDiagnostics(null, ImmutableBindingDiagnostic<AssemblySymbol>.Empty);
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/TypeSymbol.cs
index 12d51cf25be87..755781e851806 100644
--- a/src/Compilers/CSharp/Portable/Symbols/TypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/TypeSymbol.cs
@@ -12,6 +12,7 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Symbols;
 using Roslyn.Utilities;
@@ -80,13 +81,16 @@ public ConcurrentDictionary<Symbol, SymbolAndDiagnostics> ImplementationForInter
             /// an error).
             /// </summary>
             internal MultiDictionary<Symbol, Symbol> explicitInterfaceImplementationMap;
-
+#nullable enable
+            internal ImmutableDictionary<MethodSymbol, MethodSymbol>? synthesizedMethodImplMap;
+#nullable disable
             internal bool IsDefaultValue()
             {
                 return allInterfaces.IsDefault &&
                     interfacesAndTheirBaseInterfaces == null &&
                     _implementationForInterfaceMemberMap == null &&
-                    explicitInterfaceImplementationMap == null;
+                    explicitInterfaceImplementationMap == null &&
+                    synthesizedMethodImplMap == null;
             }
         }
 
@@ -449,6 +453,11 @@ public Symbol FindImplementationForInterfaceMember(Symbol interfaceMember)
 
             if (this.IsInterfaceType())
             {
+                if (interfaceMember.IsStatic)
+                {
+                    return null;
+                }
+
                 var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
                 return FindMostSpecificImplementation(interfaceMember, (NamedTypeSymbol)this, ref discardedUseSiteInfo);
             }
@@ -713,7 +722,7 @@ public ImmutableArray<SymbolDisplayPart> ToMinimalDisplayParts(
         ///  - If the first request is done with <paramref name="ignoreImplementationInInterfacesIfResultIsNotReady"/> false. A subsequent call
         ///    is guaranteed to return the same result regardless of <paramref name="ignoreImplementationInInterfacesIfResultIsNotReady"/> value.
         /// </param>
-        protected SymbolAndDiagnostics FindImplementationForInterfaceMemberInNonInterfaceWithDiagnostics(Symbol interfaceMember, bool ignoreImplementationInInterfacesIfResultIsNotReady = false)
+        internal SymbolAndDiagnostics FindImplementationForInterfaceMemberInNonInterfaceWithDiagnostics(Symbol interfaceMember, bool ignoreImplementationInInterfacesIfResultIsNotReady = false)
         {
             Debug.Assert((object)interfaceMember != null);
             Debug.Assert(!this.IsInterfaceType());
@@ -821,11 +830,11 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
             // 
             // NOTE: The batch compiler is not affected by this discrepancy, since compilations don't call these
             // APIs on symbols from other compilations.
-            bool implementingTypeIsFromSomeCompilation = implementingType.Dangerous_IsFromSomeCompilation;
+            bool implementingTypeIsFromSomeCompilation = false;
 
             Symbol implicitImpl = null;
             Symbol closestMismatch = null;
-            bool canBeImplementedImplicitly = interfaceMember.DeclaredAccessibility == Accessibility.Public && !interfaceMember.IsEventOrPropertyWithImplementableNonPublicAccessor();
+            bool canBeImplementedImplicitlyInCSharp9 = interfaceMember.DeclaredAccessibility == Accessibility.Public && !interfaceMember.IsEventOrPropertyWithImplementableNonPublicAccessor();
             TypeSymbol implementingBaseOpt = null; // Calculated only if canBeImplementedImplicitly == false
             bool implementingTypeImplementsInterface = false;
             CSharpCompilation compilation = implementingType.DeclaringCompilation;
@@ -856,7 +865,22 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
                     return null;
                 }
 
-                if (IsExplicitlyImplementedViaAccessors(interfaceMember, currType, out Symbol currTypeExplicitImpl))
+                bool checkPendingExplicitImplementations = ((object)currType != implementingType || !currType.IsDefinition);
+
+                if (checkPendingExplicitImplementations && interfaceMember is MethodSymbol interfaceMethod &&
+                    currType.InterfacesAndTheirBaseInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteInfo).ContainsKey(interfaceType))
+                {
+                    // Check for implementations that are going to be explicit once types are emitted
+                    MethodSymbol bodyOfSynthesizedMethodImpl = currType.GetBodyOfSynthesizedInterfaceMethodImpl(interfaceMethod);
+
+                    if (bodyOfSynthesizedMethodImpl is object)
+                    {
+                        implementationInInterfacesMightChangeResult = false;
+                        return bodyOfSynthesizedMethodImpl;
+                    }
+                }
+
+                if (IsExplicitlyImplementedViaAccessors(checkPendingExplicitImplementations, interfaceMember, currType, ref useSiteInfo, out Symbol currTypeExplicitImpl))
                 {
                     // We are looking for a property or event implementation and found an explicit implementation
                     // for its accessor(s) in this type. Stop the process and return event/property associated
@@ -867,17 +891,21 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
                 }
 
                 if (!seenTypeDeclaringInterface ||
-                    (!canBeImplementedImplicitly && (object)implementingBaseOpt == null))
+                    (!canBeImplementedImplicitlyInCSharp9 && (object)implementingBaseOpt == null))
                 {
                     if (currType.InterfacesAndTheirBaseInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteInfo).ContainsKey(interfaceType))
                     {
-                        seenTypeDeclaringInterface = true;
+                        if (!seenTypeDeclaringInterface)
+                        {
+                            implementingTypeIsFromSomeCompilation = currType.OriginalDefinition.ContainingModule is not PEModuleSymbol;
+                            seenTypeDeclaringInterface = true;
+                        }
 
                         if ((object)currType == implementingType)
                         {
                             implementingTypeImplementsInterface = true;
                         }
-                        else if (!canBeImplementedImplicitly && (object)implementingBaseOpt == null)
+                        else if (!canBeImplementedImplicitlyInCSharp9 && (object)implementingBaseOpt == null)
                         {
                             implementingBaseOpt = currType;
                         }
@@ -886,7 +914,8 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
 
                 // We want the implementation from the most derived type at or above the first one to
                 // include the interface (or a subinterface) in its interface list
-                if (seenTypeDeclaringInterface)
+                if (seenTypeDeclaringInterface &&
+                    (!interfaceMember.IsStatic || implementingTypeIsFromSomeCompilation))
                 {
                     //pass 2: check for implicit impls (name must match)
                     Symbol currTypeImplicitImpl;
@@ -912,9 +941,9 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
                 }
             }
 
-            Debug.Assert(!canBeImplementedImplicitly || (object)implementingBaseOpt == null);
+            Debug.Assert(!canBeImplementedImplicitlyInCSharp9 || (object)implementingBaseOpt == null);
 
-            bool tryDefaultInterfaceImplementation = true;
+            bool tryDefaultInterfaceImplementation = !interfaceMember.IsStatic;
 
             // Dev10 has some extra restrictions and extra wiggle room when finding implicit
             // implementations for interface accessors.  Perform some extra checks and possibly
@@ -973,24 +1002,26 @@ private static Symbol ComputeImplementationForInterfaceMember(Symbol interfaceMe
             {
                 if ((object)implicitImpl != null)
                 {
-                    if (!canBeImplementedImplicitly)
+                    if (!canBeImplementedImplicitlyInCSharp9)
                     {
                         if (interfaceMember.Kind == SymbolKind.Method &&
                             (object)implementingBaseOpt == null) // Otherwise any approprite errors are going to be reported for the base.
                         {
-                            diagnostics.Add(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, GetInterfaceLocation(interfaceMember, implementingType),
-                                            implementingType, interfaceMember, implicitImpl);
+                            LanguageVersion requiredVersion = MessageID.IDS_FeatureImplicitImplementationOfNonPublicMemebers.RequiredVersion();
+                            LanguageVersion? availableVersion = implementingType.DeclaringCompilation?.LanguageVersion;
+                            if (requiredVersion > availableVersion)
+                            {
+                                diagnostics.Add(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, GetInterfaceLocation(interfaceMember, implementingType),
+                                                implementingType, interfaceMember, implicitImpl,
+                                                availableVersion.GetValueOrDefault().ToDisplayString(), new CSharpRequiredLanguageVersion(requiredVersion));
+                            }
                         }
                     }
-                    else
-                    {
-                        ReportImplicitImplementationMatchDiagnostics(interfaceMember, implementingType, implicitImpl, diagnostics);
-                    }
+
+                    ReportImplicitImplementationMatchDiagnostics(interfaceMember, implementingType, implicitImpl, diagnostics);
                 }
                 else if ((object)closestMismatch != null)
                 {
-                    Debug.Assert(interfaceMember.DeclaredAccessibility == Accessibility.Public);
-                    Debug.Assert(!interfaceMember.IsEventOrPropertyWithImplementableNonPublicAccessor());
                     ReportImplicitImplementationMismatchDiagnostics(interfaceMember, implementingType, closestMismatch, diagnostics);
                 }
             }
@@ -1003,6 +1034,7 @@ private static Symbol FindMostSpecificImplementationInInterfaces(Symbol interfac
                                                                          BindingDiagnosticBag diagnostics)
         {
             Debug.Assert(!implementingType.IsInterfaceType());
+            Debug.Assert(!interfaceMember.IsStatic);
 
             // If we are dealing with a property or event and an implementation of at least one accessor is not from an interface, it 
             // wouldn't be right to say that the event/property is implemented in an interface because its accessor isn't.
@@ -1326,6 +1358,7 @@ static Symbol findMostSpecificImplementationInBases(
         internal static MultiDictionary<Symbol, Symbol>.ValueSet FindImplementationInInterface(Symbol interfaceMember, NamedTypeSymbol interfaceType)
         {
             Debug.Assert(interfaceType.IsInterface);
+            Debug.Assert(!interfaceMember.IsStatic);
 
             NamedTypeSymbol containingType = interfaceMember.ContainingType;
             if (containingType.Equals(interfaceType, TypeCompareKind.CLRSignatureCompareOptions))
@@ -1407,15 +1440,15 @@ private static (MethodSymbol interfaceAccessor1, MethodSymbol interfaceAccessor2
         /// even if it is null.  That is, never attempt to find an implicit implementation for an interface property or event with an
         /// explicitly implemented accessor.
         /// </summary>
-        private static bool IsExplicitlyImplementedViaAccessors(Symbol interfaceMember, TypeSymbol currType, out Symbol implementingMember)
+        private static bool IsExplicitlyImplementedViaAccessors(bool checkPendingExplicitImplementations, Symbol interfaceMember, TypeSymbol currType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out Symbol implementingMember)
         {
             (MethodSymbol interfaceAccessor1, MethodSymbol interfaceAccessor2) = GetImplementableAccessors(interfaceMember);
 
             Symbol associated1;
             Symbol associated2;
 
-            if (TryGetExplicitImplementationAssociatedPropertyOrEvent(interfaceAccessor1, currType, out associated1) |  // NB: not ||
-                TryGetExplicitImplementationAssociatedPropertyOrEvent(interfaceAccessor2, currType, out associated2))
+            if (TryGetExplicitImplementationAssociatedPropertyOrEvent(checkPendingExplicitImplementations, interfaceAccessor1, currType, ref useSiteInfo, out associated1) |  // NB: not ||
+                TryGetExplicitImplementationAssociatedPropertyOrEvent(checkPendingExplicitImplementations, interfaceAccessor2, currType, ref useSiteInfo, out associated2))
             {
                 // If there's more than one associated property/event, don't do anything special - just let the algorithm
                 // fail in the usual way.
@@ -1427,7 +1460,7 @@ private static bool IsExplicitlyImplementedViaAccessors(Symbol interfaceMember,
                     // If we haven't then there is no implementation.  We need this check to match dev11 in some edge cases
                     // (e.g. IndexerTests.AmbiguousExplicitIndexerImplementation).  Such cases already fail
                     // to roundtrip correctly, so it's not important to check for a particular compilation.
-                    if ((object)implementingMember != null && implementingMember.Dangerous_IsFromSomeCompilation)
+                    if ((object)implementingMember != null && implementingMember.OriginalDefinition.ContainingModule is not PEModuleSymbol && implementingMember.IsExplicitInterfaceImplementation())
                     {
                         implementingMember = null;
                     }
@@ -1444,7 +1477,7 @@ private static bool IsExplicitlyImplementedViaAccessors(Symbol interfaceMember,
             return false;
         }
 
-        private static bool TryGetExplicitImplementationAssociatedPropertyOrEvent(MethodSymbol interfaceAccessor, TypeSymbol currType, out Symbol associated)
+        private static bool TryGetExplicitImplementationAssociatedPropertyOrEvent(bool checkPendingExplicitImplementations, MethodSymbol interfaceAccessor, TypeSymbol currType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out Symbol associated)
         {
             if ((object)interfaceAccessor != null)
             {
@@ -1459,6 +1492,19 @@ private static bool TryGetExplicitImplementationAssociatedPropertyOrEvent(Method
                         : null;
                     return true;
                 }
+
+                if (checkPendingExplicitImplementations &&
+                    currType.InterfacesAndTheirBaseInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteInfo).ContainsKey(interfaceAccessor.ContainingType))
+                {
+                    // Check for implementations that are going to be explicit once types are emitted
+                    MethodSymbol bodyOfSynthesizedMethodImpl = currType.GetBodyOfSynthesizedInterfaceMethodImpl(interfaceAccessor);
+
+                    if (bodyOfSynthesizedMethodImpl is object)
+                    {
+                        associated = bodyOfSynthesizedMethodImpl.AssociatedSymbol;
+                        return true;
+                    }
+                }
             }
 
             associated = null;
@@ -1545,6 +1591,7 @@ private static void CheckForImplementationOfCorrespondingPropertyOrEvent(MethodS
                     interfaceMethod.Parameters,
                     interfaceMethod.RefKind,
                     interfaceMethod.IsInitOnly,
+                    interfaceMethod.IsStatic,
                     interfaceMethod.ReturnTypeWithAnnotations,
                     interfaceMethod.RefCustomModifiers,
                     interfaceMethod.ExplicitInterfaceImplementations);
@@ -1616,6 +1663,10 @@ private static void ReportImplicitImplementationMatchDiagnostics(Symbol interfac
                         // CS0629: Conditional member '{0}' cannot implement interface member '{1}' in type '{2}'
                         diagnostics.Add(ErrorCode.ERR_InterfaceImplementedByConditional, GetImplicitImplementationDiagnosticLocation(interfaceMember, implementingType, implicitImpl), implicitImpl, interfaceMethod, implementingType);
                     }
+                    else if (implicitImplMethod.IsStatic && implicitImplMethod.MethodKind == MethodKind.Ordinary && implicitImplMethod.GetUnmanagedCallersOnlyAttributeData(forceComplete: true) is not null)
+                    {
+                        diagnostics.Add(ErrorCode.ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod, GetImplicitImplementationDiagnosticLocation(interfaceMember, implementingType, implicitImpl), implicitImpl, interfaceMethod, implementingType);
+                    }
                     else if (ReportAnyMismatchedConstraints(interfaceMethod, implementingType, implicitImplMethod, diagnostics))
                     {
                         reportedAnError = true;
@@ -1653,6 +1704,13 @@ private static void ReportImplicitImplementationMatchDiagnostics(Symbol interfac
                     }
                 }
             }
+
+            if (implicitImpl.IsStatic && !implementingType.ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)
+            {
+                diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember,
+                                GetInterfaceLocation(interfaceMember, implementingType),
+                                implicitImpl, interfaceMember, implementingType);
+            }
         }
 
         internal static void CheckNullableReferenceTypeMismatchOnImplementingMember(TypeSymbol implementingType, Symbol implementingMember, Symbol interfaceMember, bool isExplicit, BindingDiagnosticBag diagnostics)
@@ -1800,9 +1858,10 @@ private static void ReportImplicitImplementationMismatchDiagnostics(Symbol inter
             // Determine  a better location for diagnostic squiggles.  Squiggle the interface rather than the class.
             Location interfaceLocation = GetInterfaceLocation(interfaceMember, implementingType);
 
-            if (closestMismatch.IsStatic)
+            if (closestMismatch.IsStatic != interfaceMember.IsStatic)
             {
-                diagnostics.Add(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, interfaceLocation, implementingType, interfaceMember, closestMismatch);
+                diagnostics.Add(closestMismatch.IsStatic ? ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic : ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotStatic,
+                                interfaceLocation, implementingType, interfaceMember, closestMismatch);
             }
             else if (closestMismatch.DeclaredAccessibility != Accessibility.Public)
             {
@@ -1982,10 +2041,23 @@ private static void FindPotentialImplicitImplementationMemberDeclaredInType(
             implicitImpl = null;
             closeMismatch = null;
 
+            bool? isOperator = null;
+
+            if (interfaceMember is MethodSymbol interfaceMethod)
+            {
+                isOperator = interfaceMethod.MethodKind is MethodKind.UserDefinedOperator or MethodKind.Conversion;
+            }
+
             foreach (Symbol member in currType.GetMembers(interfaceMember.Name))
             {
                 if (member.Kind == interfaceMember.Kind)
                 {
+                    if (isOperator.HasValue &&
+                        (((MethodSymbol)member).MethodKind is MethodKind.UserDefinedOperator or MethodKind.Conversion) != isOperator.GetValueOrDefault())
+                    {
+                        continue;
+                    }
+
                     if (IsInterfaceMemberImplementation(member, interfaceMember, implementingTypeIsFromSomeCompilation))
                     {
                         implicitImpl = member;
@@ -1993,11 +2065,7 @@ private static void FindPotentialImplicitImplementationMemberDeclaredInType(
                     }
 
                     // If we haven't found a match, do a weaker comparison that ignores static-ness, accessibility, and return type.
-                    // But do this only if interface member is public because language doesn't allow implicit implementations for
-                    // non-public members and, since candidate's signature doesn't match, runtime will never pick it up either. 
-                    else if ((object)closeMismatch == null && implementingTypeIsFromSomeCompilation &&
-                             interfaceMember.DeclaredAccessibility == Accessibility.Public &&
-                             !interfaceMember.IsEventOrPropertyWithImplementableNonPublicAccessor())
+                    else if ((object)closeMismatch == null && implementingTypeIsFromSomeCompilation)
                     {
                         // We can ignore custom modifiers here, because our goal is to improve the helpfulness
                         // of an error we're already giving, rather than to generate a new error.
@@ -2039,7 +2107,7 @@ private static void FindPotentialImplicitImplementationMemberDeclaredInType(
         /// </remarks>
         private static bool IsInterfaceMemberImplementation(Symbol candidateMember, Symbol interfaceMember, bool implementingTypeIsFromSomeCompilation)
         {
-            if (candidateMember.DeclaredAccessibility != Accessibility.Public || candidateMember.IsStatic)
+            if (candidateMember.DeclaredAccessibility != Accessibility.Public || candidateMember.IsStatic != interfaceMember.IsStatic)
             {
                 return false;
             }
@@ -2096,6 +2164,63 @@ private MultiDictionary<Symbol, Symbol> MakeExplicitInterfaceImplementationMap()
             return map;
         }
 
+#nullable enable
+        /// <summary>
+        /// If implementation of an interface method <paramref name="interfaceMethod"/> will be accompanied with 
+        /// a MethodImpl entry in metadata, information about which isn't already exposed through
+        /// <see cref="MethodSymbol.ExplicitInterfaceImplementations"/> API, this method returns the "Body" part
+        /// of the MethodImpl entry, i.e. the method that implements the <paramref name="interfaceMethod"/>.
+        /// Some of the MethodImpl entries could require synthetic forwarding methods. In such cases,
+        /// the result is the method that the language considers to implement the <paramref name="interfaceMethod"/>,
+        /// rather than the forwarding method. In other words, it is the method that the forwarding method forwards to.
+        /// </summary>
+        /// <param name="interfaceMethod">The interface method that is going to be implemented by using synthesized MethodImpl entry.</param>
+        /// <returns></returns>
+        protected MethodSymbol? GetBodyOfSynthesizedInterfaceMethodImpl(MethodSymbol interfaceMethod)
+        {
+            var info = this.GetInterfaceInfo();
+            if (info == s_noInterfaces)
+            {
+                return null;
+            }
+
+            if (info.synthesizedMethodImplMap == null)
+            {
+                Interlocked.CompareExchange(ref info.synthesizedMethodImplMap, makeSynthesizedMethodImplMap(), null);
+            }
+
+            if (info.synthesizedMethodImplMap.TryGetValue(interfaceMethod, out MethodSymbol? result))
+            {
+                return result;
+            }
+
+            return null;
+
+            ImmutableDictionary<MethodSymbol, MethodSymbol> makeSynthesizedMethodImplMap()
+            {
+                var map = ImmutableDictionary.CreateBuilder<MethodSymbol, MethodSymbol>(ExplicitInterfaceImplementationTargetMemberEqualityComparer.Instance);
+                foreach ((MethodSymbol body, MethodSymbol implemented) in this.SynthesizedInterfaceMethodImpls())
+                {
+                    map.Add(implemented, body);
+                }
+
+                return map.ToImmutable();
+            }
+        }
+
+        /// <summary>
+        /// Returns information about interface method implementations that will be accompanied with 
+        /// MethodImpl entries in metadata, information about which isn't already exposed through
+        /// <see cref="MethodSymbol.ExplicitInterfaceImplementations"/> API. The "Body" is the method that
+        /// implements the interface method "Implemented". 
+        /// Some of the MethodImpl entries could require synthetic forwarding methods. In such cases,
+        /// the "Body" is the method that the language considers to implement the interface method,
+        /// the "Implemented", rather than the forwarding method. In other words, it is the method that 
+        /// the forwarding method forwards to.
+        /// </summary>
+        internal abstract IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls();
+#nullable disable
+
         protected class ExplicitInterfaceImplementationTargetMemberEqualityComparer : IEqualityComparer<Symbol>
         {
             public static readonly ExplicitInterfaceImplementationTargetMemberEqualityComparer Instance = new ExplicitInterfaceImplementationTargetMemberEqualityComparer();
diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
index 3a591f09912b0..82efcc15fda5e 100644
--- a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
@@ -1647,17 +1647,7 @@ internal static bool IsCustomTaskType(this NamedTypeSymbol type, [NotNullWhen(tr
             var arity = type.Arity;
             if (arity < 2)
             {
-                // Find the AsyncBuilder attribute.
-                foreach (var attr in type.GetAttributes())
-                {
-                    if (attr.IsTargetAttribute(type, AttributeDescription.AsyncMethodBuilderAttribute)
-                        && attr.CommonConstructorArguments.Length == 1
-                        && attr.CommonConstructorArguments[0].Kind == TypedConstantKind.Type)
-                    {
-                        builderArgument = attr.CommonConstructorArguments[0].ValueInternal!;
-                        return true;
-                    }
-                }
+                return type.HasAsyncMethodBuilderAttribute(out builderArgument);
             }
 
             builderArgument = null;
@@ -1938,17 +1928,6 @@ private static bool IsContainedInNamespace(this TypeSymbol typeSymbol, string ou
             return globalNamespace != null && globalNamespace.IsGlobalNamespace;
         }
 
-        public static bool IsBadAsyncReturn(this TypeSymbol returnType, CSharpCompilation declaringCompilation)
-        {
-            // Note: we're passing the return type explicitly (rather than using `method.ReturnType`) to avoid cycles
-            return !returnType.IsErrorType() &&
-                !returnType.IsVoidType() &&
-                !returnType.IsNonGenericTaskType(declaringCompilation) &&
-                !returnType.IsGenericTaskType(declaringCompilation) &&
-                !returnType.IsIAsyncEnumerableType(declaringCompilation) &&
-                !returnType.IsIAsyncEnumeratorType(declaringCompilation);
-        }
-
         internal static int TypeToIndex(this TypeSymbol type)
         {
             switch (type.GetSpecialTypeSafe())
diff --git a/src/Compilers/CSharp/Portable/Symbols/VarianceSafety.cs b/src/Compilers/CSharp/Portable/Symbols/VarianceSafety.cs
index 5fb05d5dbe891..81252677ebf21 100644
--- a/src/Compilers/CSharp/Portable/Symbols/VarianceSafety.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/VarianceSafety.cs
@@ -171,7 +171,7 @@ private static void CheckMethodVarianceSafety(this MethodSymbol method, Location
 
         private static bool SkipVarianceSafetyChecks(Symbol member)
         {
-            if (member.IsStatic)
+            if (member.IsStatic && !member.IsAbstract)
             {
                 return MessageID.IDS_FeatureVarianceSafetyForStaticInterfaceMembers.RequiredVersion() <= member.DeclaringCompilation.LanguageVersion;
             }
@@ -469,7 +469,7 @@ private static void AddVarianceError<T>(
             // "requires output-safe", and "requires input-safe and output-safe".  This would make the error codes much easier to document and
             // much more actionable.
             // UNDONE: related location for use is much more useful
-            if (!(context is TypeSymbol) && context.IsStatic)
+            if (!(context is TypeSymbol) && context.IsStatic && !context.IsAbstract)
             {
                 diagnostics.Add(ErrorCode.ERR_UnexpectedVarianceStaticMember, location, context, unsafeTypeParameter, actualVariance.Localize(), expectedVariance.Localize(),
                                 new CSharpRequiredLanguageVersion(MessageID.IDS_FeatureVarianceSafetyForStaticInterfaceMembers.RequiredVersion()));
diff --git a/src/Compilers/CSharp/Portable/Syntax/CSharpLineDirectiveMap.cs b/src/Compilers/CSharp/Portable/Syntax/CSharpLineDirectiveMap.cs
index a254beef31ac5..8fed47ddfd464 100644
--- a/src/Compilers/CSharp/Portable/Syntax/CSharpLineDirectiveMap.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/CSharpLineDirectiveMap.cs
@@ -21,27 +21,34 @@ public CSharpLineDirectiveMap(SyntaxTree syntaxTree)
         // Add all active #line directives under trivia into the list, in source code order.
         protected override bool ShouldAddDirective(DirectiveTriviaSyntax directive)
         {
-            return directive.IsActive && directive.Kind() == SyntaxKind.LineDirectiveTrivia;
+            return directive.IsActive && (directive.Kind() is SyntaxKind.LineDirectiveTrivia or SyntaxKind.LineSpanDirectiveTrivia);
         }
 
         // Given a directive and the previous entry, create a new entry.
         protected override LineMappingEntry GetEntry(DirectiveTriviaSyntax directiveNode, SourceText sourceText, LineMappingEntry previous)
         {
             Debug.Assert(ShouldAddDirective(directiveNode));
-            var directive = (LineDirectiveTriviaSyntax)directiveNode;
 
             // Get line number of NEXT line, hence the +1.
-            var directiveLineNumber = sourceText.Lines.IndexOf(directive.SpanStart) + 1;
+            var directiveLineNumber = sourceText.Lines.IndexOf(directiveNode.SpanStart) + 1;
+
+            if (directiveNode is LineSpanDirectiveTriviaSyntax spanDirective)
+            {
+                return GetLineSpanDirectiveEntry(spanDirective, directiveLineNumber);
+            }
+
+            var directive = (LineDirectiveTriviaSyntax)directiveNode;
 
             // The default for the current entry does the same thing as the previous entry, except
             // resetting hidden.
             var unmappedLine = directiveLineNumber;
-            var mappedLine = previous.MappedLine + directiveLineNumber - previous.UnmappedLine;
-            var mappedPathOpt = previous.MappedPathOpt;
+            var mappedLine = (previous.State == PositionState.RemappedSpan) ? unmappedLine : previous.MappedLine + directiveLineNumber - previous.UnmappedLine;
+            var mappedPathOpt = (previous.State == PositionState.RemappedSpan) ? null : previous.MappedPathOpt;
             PositionState state = PositionState.Unmapped;
 
             // Modify the current entry based on the directive.
             SyntaxToken lineToken = directive.Line;
+
             if (!lineToken.IsMissing)
             {
                 switch (lineToken.Kind())
@@ -86,6 +93,78 @@ protected override LineMappingEntry GetEntry(DirectiveTriviaSyntax directiveNode
                 state);
         }
 
+        private static LineMappingEntry GetLineSpanDirectiveEntry(LineSpanDirectiveTriviaSyntax spanDirective, int unmappedLine)
+        {
+            if (!spanDirective.HasErrors &&
+                tryGetPosition(spanDirective.Start, isEnd: false, out LinePosition mappedStart) &&
+                tryGetPosition(spanDirective.End, isEnd: true, out LinePosition mappedEnd) &&
+                tryGetOptionalCharacterOffset(spanDirective.CharacterOffset, out int? characterOffset) &&
+                tryGetStringLiteralValue(spanDirective.File, out string? mappedPathOpt))
+            {
+                return new LineMappingEntry(unmappedLine, new LinePositionSpan(mappedStart, mappedEnd), characterOffset, mappedPathOpt);
+            }
+            return new LineMappingEntry(unmappedLine, unmappedLine, mappedPathOpt: null, PositionState.Unmapped);
+
+            static bool tryGetOneBasedNumericLiteralValue(in SyntaxToken token, out int value)
+            {
+                if (!token.IsMissing &&
+                    token.Kind() == SyntaxKind.NumericLiteralToken &&
+                    token.Value is int tokenValue)
+                {
+                    // convert one-based line number into zero-based line number
+                    value = tokenValue - 1;
+                    return true;
+                }
+                value = 0;
+                return false;
+            }
+
+            static bool tryGetStringLiteralValue(in SyntaxToken token, out string? value)
+            {
+                if (token.Kind() == SyntaxKind.StringLiteralToken)
+                {
+                    value = (string?)token.Value;
+                    return true;
+                }
+                value = null;
+                return false;
+            }
+
+            // returns false on error
+            static bool tryGetOptionalCharacterOffset(in SyntaxToken token, out int? value)
+            {
+                if (!token.IsMissing)
+                {
+                    if (token.Kind() == SyntaxKind.None)
+                    {
+                        value = null;
+                        return true;
+                    }
+                    int val = 0;
+                    if (tryGetOneBasedNumericLiteralValue(token, out val))
+                    {
+                        value = val;
+                        return true;
+                    }
+                }
+                value = null;
+                return false;
+            }
+
+            // returns false on error
+            static bool tryGetPosition(LineDirectivePositionSyntax syntax, bool isEnd, out LinePosition position)
+            {
+                if (tryGetOneBasedNumericLiteralValue(syntax.Line, out int line) &&
+                    tryGetOneBasedNumericLiteralValue(syntax.Character, out int character))
+                {
+                    position = new LinePosition(line, isEnd ? character + 1 : character);
+                    return true;
+                }
+                position = default;
+                return false;
+            }
+        }
+
         protected override LineMappingEntry InitializeFirstEntry()
         {
             // The first entry of the map is always 0,0,null,Unmapped -- the default mapping.
@@ -125,6 +204,7 @@ public override LineVisibility GetLineVisibility(SourceText sourceText, int posi
                     }
 
                 case PositionState.Remapped:
+                case PositionState.RemappedSpan:
                     return LineVisibility.Visible;
 
                 case PositionState.Hidden:
diff --git a/src/Compilers/CSharp/Portable/Syntax/ConversionOperatorDeclarationSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/ConversionOperatorDeclarationSyntax.cs
new file mode 100644
index 0000000000000..a59184c90ac57
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Syntax/ConversionOperatorDeclarationSyntax.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.CSharp.Syntax
+{
+    public partial class ConversionOperatorDeclarationSyntax
+    {
+        public ConversionOperatorDeclarationSyntax Update(
+            SyntaxList<AttributeListSyntax> attributeLists,
+            SyntaxTokenList modifiers,
+            SyntaxToken implicitOrExplicitKeyword,
+            SyntaxToken operatorKeyword,
+            TypeSyntax type,
+            ParameterListSyntax parameterList,
+            BlockSyntax? body,
+            ArrowExpressionClauseSyntax? expressionBody,
+            SyntaxToken semicolonToken)
+        {
+            return Update(
+                attributeLists: attributeLists,
+                modifiers: modifiers,
+                implicitOrExplicitKeyword: implicitOrExplicitKeyword,
+                explicitInterfaceSpecifier: this.ExplicitInterfaceSpecifier,
+                operatorKeyword: operatorKeyword,
+                type: type,
+                parameterList: parameterList,
+                body: body,
+                expressionBody: expressionBody,
+                semicolonToken: semicolonToken);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Syntax/DirectiveTriviaSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/DirectiveTriviaSyntax.cs
index 7f54658e6f8f3..e363d1d82abde 100644
--- a/src/Compilers/CSharp/Portable/Syntax/DirectiveTriviaSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/DirectiveTriviaSyntax.cs
@@ -44,6 +44,8 @@ public SyntaxToken DirectiveNameToken
                         return ((UndefDirectiveTriviaSyntax)this).UndefKeyword;
                     case SyntaxKind.LineDirectiveTrivia:
                         return ((LineDirectiveTriviaSyntax)this).LineKeyword;
+                    case SyntaxKind.LineSpanDirectiveTrivia:
+                        return ((LineSpanDirectiveTriviaSyntax)this).LineKeyword;
                     case SyntaxKind.PragmaWarningDirectiveTrivia:
                         return ((PragmaWarningDirectiveTriviaSyntax)this).PragmaKeyword;
                     case SyntaxKind.PragmaChecksumDirectiveTrivia:
diff --git a/src/Compilers/CSharp/Portable/Syntax/IfStatementSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/IfStatementSyntax.cs
index bb848eccd64e4..e226bf236f3dc 100644
--- a/src/Compilers/CSharp/Portable/Syntax/IfStatementSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/IfStatementSyntax.cs
@@ -8,7 +8,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Syntax
 {
     public partial class IfStatementSyntax
     {
-        public IfStatementSyntax Update(SyntaxToken ifKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, StatementSyntax statement, ElseClauseSyntax @else)
+        public IfStatementSyntax Update(SyntaxToken ifKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, StatementSyntax statement, ElseClauseSyntax? @else)
             => Update(AttributeLists, ifKeyword, openParenToken, condition, closeParenToken, statement, @else);
     }
 }
@@ -17,10 +17,10 @@ namespace Microsoft.CodeAnalysis.CSharp
 {
     public partial class SyntaxFactory
     {
-        public static IfStatementSyntax IfStatement(ExpressionSyntax condition, StatementSyntax statement, ElseClauseSyntax @else)
+        public static IfStatementSyntax IfStatement(ExpressionSyntax condition, StatementSyntax statement, ElseClauseSyntax? @else)
             => IfStatement(attributeLists: default, condition, statement, @else);
 
-        public static IfStatementSyntax IfStatement(SyntaxToken ifKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, StatementSyntax statement, ElseClauseSyntax @else)
+        public static IfStatementSyntax IfStatement(SyntaxToken ifKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, StatementSyntax statement, ElseClauseSyntax? @else)
             => IfStatement(attributeLists: default, ifKeyword, openParenToken, condition, closeParenToken, statement, @else);
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Syntax/OperatorDeclarationSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/OperatorDeclarationSyntax.cs
new file mode 100644
index 0000000000000..75c87324af6b2
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Syntax/OperatorDeclarationSyntax.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.CSharp.Syntax
+{
+    public partial class OperatorDeclarationSyntax
+    {
+        public OperatorDeclarationSyntax Update(
+            SyntaxList<AttributeListSyntax> attributeLists,
+            SyntaxTokenList modifiers,
+            TypeSyntax returnType,
+            SyntaxToken operatorKeyword,
+            SyntaxToken operatorToken,
+            ParameterListSyntax parameterList,
+            BlockSyntax? body,
+            ArrowExpressionClauseSyntax? expressionBody,
+            SyntaxToken semicolonToken)
+        {
+            return Update(
+                attributeLists: attributeLists,
+                modifiers: modifiers,
+                returnType: returnType,
+                explicitInterfaceSpecifier: this.ExplicitInterfaceSpecifier,
+                operatorKeyword: operatorKeyword,
+                operatorToken: operatorToken,
+                parameterList: parameterList,
+                body: body,
+                expressionBody: expressionBody,
+                semicolonToken: semicolonToken);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Syntax/ParenthesizedLambdaExpressionSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/ParenthesizedLambdaExpressionSyntax.cs
index 64a454143eb49..cd754fc6bf5de 100644
--- a/src/Compilers/CSharp/Portable/Syntax/ParenthesizedLambdaExpressionSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/ParenthesizedLambdaExpressionSyntax.cs
@@ -32,6 +32,9 @@ public ParenthesizedLambdaExpressionSyntax Update(SyntaxToken asyncKeyword, Para
 
         public ParenthesizedLambdaExpressionSyntax Update(SyntaxTokenList modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
             => Update(this.AttributeLists, modifiers, parameterList, arrowToken, block, expressionBody);
+
+        public ParenthesizedLambdaExpressionSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
+            => Update(attributeLists, modifiers, returnType: null, parameterList, arrowToken, block, expressionBody);
     }
 }
 
@@ -46,9 +49,12 @@ public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(
             => ParenthesizedLambdaExpression(default(SyntaxTokenList), parameterList, block, expressionBody);
 
         public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxTokenList modifiers, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody)
-            => SyntaxFactory.ParenthesizedLambdaExpression(attributeLists: default, modifiers, parameterList, arrowToken, block, expressionBody);
+            => SyntaxFactory.ParenthesizedLambdaExpression(attributeLists: default, modifiers, returnType: null, parameterList, arrowToken, block, expressionBody);
 
         public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxTokenList modifiers, ParameterListSyntax parameterList, BlockSyntax? block, ExpressionSyntax? expressionBody)
             => SyntaxFactory.ParenthesizedLambdaExpression(attributeLists: default, modifiers, parameterList, block, expressionBody);
+
+        public static ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, ParameterListSyntax parameterList, BlockSyntax? block, ExpressionSyntax? expressionBody)
+            => SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, returnType: null, parameterList, block, expressionBody);
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Syntax/PropertyDeclarationSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/PropertyDeclarationSyntax.cs
index aff5609cb9091..60e11dd855e08 100644
--- a/src/Compilers/CSharp/Portable/Syntax/PropertyDeclarationSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/PropertyDeclarationSyntax.cs
@@ -31,7 +31,7 @@ public PropertyDeclarationSyntax WithSemicolon(SyntaxToken semicolon)
     // backwards compatibility for API extension
     public sealed partial class AccessorDeclarationSyntax : CSharpSyntaxNode
     {
-        public AccessorDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, BlockSyntax body, SyntaxToken semicolonToken)
+        public AccessorDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, BlockSyntax? body, SyntaxToken semicolonToken)
             => Update(attributeLists, modifiers, keyword, body, expressionBody: null, semicolonToken);
     }
 }
@@ -41,7 +41,7 @@ namespace Microsoft.CodeAnalysis.CSharp
     public partial class SyntaxFactory
     {
         /// <summary>Creates a new AccessorDeclarationSyntax instance.</summary>
-        public static AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, BlockSyntax body)
+        public static AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, BlockSyntax? body)
         {
             return SyntaxFactory.AccessorDeclaration(kind, default(SyntaxList<AttributeListSyntax>), default(SyntaxTokenList), SyntaxFactory.Token(GetAccessorDeclarationKeywordKind(kind)), body, expressionBody: null, default(SyntaxToken));
         }
diff --git a/src/Compilers/CSharp/Portable/Syntax/ReturnStatementSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/ReturnStatementSyntax.cs
index a7fe55847f0da..2d3e12b02f4c0 100644
--- a/src/Compilers/CSharp/Portable/Syntax/ReturnStatementSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/ReturnStatementSyntax.cs
@@ -8,7 +8,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Syntax
 {
     public partial class ReturnStatementSyntax
     {
-        public ReturnStatementSyntax Update(SyntaxToken returnKeyword, ExpressionSyntax expression, SyntaxToken semicolonToken)
+        public ReturnStatementSyntax Update(SyntaxToken returnKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken)
             => Update(AttributeLists, returnKeyword, expression, semicolonToken);
     }
 }
@@ -17,7 +17,7 @@ namespace Microsoft.CodeAnalysis.CSharp
 {
     public partial class SyntaxFactory
     {
-        public static ReturnStatementSyntax ReturnStatement(SyntaxToken returnKeyword, ExpressionSyntax expression, SyntaxToken semicolonToken)
+        public static ReturnStatementSyntax ReturnStatement(SyntaxToken returnKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken)
             => ReturnStatement(attributeLists: default, returnKeyword, expression, semicolonToken);
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml
index fadd8d344c368..b8cabf7960bcb 100644
--- a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml
+++ b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml
@@ -1458,6 +1458,7 @@
     <Kind Name="ParenthesizedLambdaExpression"/>
     <Field Name="AttributeLists" Type="SyntaxList&lt;AttributeListSyntax&gt;" Override="true"/>
     <Field Name="Modifiers" Type="SyntaxList&lt;SyntaxToken&gt;" Override="true"/>
+    <Field Name="ReturnType" Type="TypeSyntax" Optional="true"/>
     <Field Name="ParameterList" Type="ParameterListSyntax">
       <PropertyComment>
         <summary>ParameterListSyntax node representing the list of parameters for the lambda expression.</summary>
@@ -3730,6 +3731,7 @@
         <summary>Gets the return type.</summary>
       </PropertyComment>
     </Field>
+    <Field Name="ExplicitInterfaceSpecifier" Type="ExplicitInterfaceSpecifierSyntax" Optional="true"/>
     <Field Name="OperatorKeyword" Type="SyntaxToken">
       <PropertyComment>
         <summary>Gets the "operator" keyword.</summary>
@@ -3793,6 +3795,7 @@
       <Kind Name="ImplicitKeyword"/>
       <Kind Name="ExplicitKeyword"/>
     </Field>
+    <Field Name="ExplicitInterfaceSpecifier" Type="ExplicitInterfaceSpecifierSyntax" Optional="true"/>
     <Field Name="OperatorKeyword" Type="SyntaxToken">
       <PropertyComment>
         <summary>Gets the "operator" token.</summary>
@@ -4732,12 +4735,16 @@
     </Field>
     <Field Name="IsActive" Type="bool" Override="true"/>
   </Node>
-  <Node Name="LineDirectiveTriviaSyntax" Base="DirectiveTriviaSyntax">
+  <AbstractNode Name="LineOrSpanDirectiveTriviaSyntax" Base="DirectiveTriviaSyntax">
+    <Field Name="LineKeyword" Type="SyntaxToken" />
+    <Field Name="File" Type="SyntaxToken" Optional="true" />
+  </AbstractNode>
+  <Node Name="LineDirectiveTriviaSyntax" Base="LineOrSpanDirectiveTriviaSyntax">
     <Kind Name="LineDirectiveTrivia"/>
     <Field Name="HashToken" Type="SyntaxToken" Override="true">
       <Kind Name="HashToken"/>
     </Field>
-    <Field Name="LineKeyword" Type="SyntaxToken">
+    <Field Name="LineKeyword" Type="SyntaxToken" Override="true">
       <Kind Name="LineKeyword"/>
     </Field>
     <Field Name="Line" Type="SyntaxToken">
@@ -4745,7 +4752,49 @@
       <Kind Name="DefaultKeyword"/>
       <Kind Name="HiddenKeyword"/>
     </Field>
-    <Field Name="File" Type="SyntaxToken" Optional="true">
+    <Field Name="File" Type="SyntaxToken" Optional="true" Override="true">
+      <Kind Name="StringLiteralToken"/>
+    </Field>
+    <Field Name="EndOfDirectiveToken" Type="SyntaxToken" Override="true">
+      <Kind Name="EndOfDirectiveToken"/>
+    </Field>
+    <Field Name="IsActive" Type="bool" Override="true"/>
+  </Node>
+  <Node Name="LineDirectivePositionSyntax" Base="CSharpSyntaxNode">
+    <Kind Name="LineDirectivePosition"/>
+    <Field Name="OpenParenToken" Type="SyntaxToken">
+      <Kind Name="OpenParenToken"/>
+    </Field>
+    <Field Name="Line" Type="SyntaxToken">
+      <Kind Name="NumericLiteralToken"/>
+    </Field>
+    <Field Name="CommaToken" Type="SyntaxToken">
+      <Kind Name="CommaToken"/>
+    </Field>
+    <Field Name="Character" Type="SyntaxToken">
+      <Kind Name="NumericLiteralToken"/>
+    </Field>
+    <Field Name="CloseParenToken" Type="SyntaxToken">
+      <Kind Name="CloseParenToken"/>
+    </Field>
+  </Node>
+  <Node Name="LineSpanDirectiveTriviaSyntax" Base="LineOrSpanDirectiveTriviaSyntax">
+    <Kind Name="LineSpanDirectiveTrivia"/>
+    <Field Name="HashToken" Type="SyntaxToken" Override="true">
+      <Kind Name="HashToken"/>
+    </Field>
+    <Field Name="LineKeyword" Type="SyntaxToken" Override="true">
+      <Kind Name="LineKeyword"/>
+    </Field>
+     <Field Name="Start" Type="LineDirectivePositionSyntax" />
+     <Field Name="MinusToken" Type="SyntaxToken">
+      <Kind Name="MinusToken"/>
+    </Field>
+    <Field Name="End" Type="LineDirectivePositionSyntax" />
+    <Field Name="CharacterOffset" Type="SyntaxToken"  Optional="true">
+      <Kind Name="NumericLiteralToken"/>
+    </Field>
+    <Field Name="File" Type="SyntaxToken" Override="true">
       <Kind Name="StringLiteralToken"/>
     </Field>
     <Field Name="EndOfDirectiveToken" Type="SyntaxToken" Override="true">
diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxFactory.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxFactory.cs
index a2f323bca3095..64d26a923f699 100644
--- a/src/Compilers/CSharp/Portable/Syntax/SyntaxFactory.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxFactory.cs
@@ -1402,7 +1402,7 @@ public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(IEnumerable<TNode>
         /// <param name="nodes">A sequence of syntax nodes.</param>
         /// <param name="separators">A sequence of token to be interleaved between the nodes. The number of tokens must
         /// be one less than the number of nodes.</param>
-        public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(IEnumerable<TNode> nodes, IEnumerable<SyntaxToken> separators) where TNode : SyntaxNode
+        public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(IEnumerable<TNode>? nodes, IEnumerable<SyntaxToken>? separators) where TNode : SyntaxNode
         {
             // Interleave the nodes and the separators.  The number of separators must be equal to or 1 less than the number of nodes or
             // an argument exception is thrown.
@@ -2468,6 +2468,50 @@ public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(
                 semicolonToken: semicolonToken);
         }
 
+        public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(
+            SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers,
+            SyntaxToken implicitOrExplicitKeyword,
+            SyntaxToken operatorKeyword,
+            TypeSyntax type,
+            ParameterListSyntax parameterList,
+            BlockSyntax? body,
+            ArrowExpressionClauseSyntax? expressionBody,
+            SyntaxToken semicolonToken)
+        {
+            return SyntaxFactory.ConversionOperatorDeclaration(
+                attributeLists: attributeLists,
+                modifiers: modifiers,
+                implicitOrExplicitKeyword: implicitOrExplicitKeyword,
+                explicitInterfaceSpecifier: null,
+                operatorKeyword: operatorKeyword,
+                type: type,
+                parameterList: parameterList,
+                body: body,
+                expressionBody: expressionBody,
+                semicolonToken: semicolonToken);
+        }
+
+        public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(
+            SyntaxList<AttributeListSyntax> attributeLists,
+            SyntaxTokenList modifiers,
+            SyntaxToken implicitOrExplicitKeyword,
+            TypeSyntax type,
+            ParameterListSyntax parameterList,
+            BlockSyntax? body,
+            ArrowExpressionClauseSyntax? expressionBody)
+        {
+            return SyntaxFactory.ConversionOperatorDeclaration(
+                attributeLists: attributeLists,
+                modifiers: modifiers,
+                implicitOrExplicitKeyword: implicitOrExplicitKeyword,
+                explicitInterfaceSpecifier: null,
+                type: type,
+                parameterList: parameterList,
+                body: body,
+                expressionBody: expressionBody);
+        }
+
+        /// <summary>Creates a new OperatorDeclarationSyntax instance.</summary>
         public static OperatorDeclarationSyntax OperatorDeclaration(
             SyntaxList<AttributeListSyntax> attributeLists,
             SyntaxTokenList modifiers,
@@ -2490,6 +2534,52 @@ public static OperatorDeclarationSyntax OperatorDeclaration(
                 semicolonToken: semicolonToken);
         }
 
+        /// <summary>Creates a new OperatorDeclarationSyntax instance.</summary>
+        public static OperatorDeclarationSyntax OperatorDeclaration(
+            SyntaxList<AttributeListSyntax> attributeLists,
+            SyntaxTokenList modifiers,
+            TypeSyntax returnType,
+            SyntaxToken operatorKeyword,
+            SyntaxToken operatorToken,
+            ParameterListSyntax parameterList,
+            BlockSyntax? body,
+            ArrowExpressionClauseSyntax? expressionBody,
+            SyntaxToken semicolonToken)
+        {
+            return SyntaxFactory.OperatorDeclaration(
+                attributeLists: attributeLists,
+                modifiers: modifiers,
+                returnType: returnType,
+                explicitInterfaceSpecifier: null,
+                operatorKeyword: operatorKeyword,
+                operatorToken: operatorToken,
+                parameterList: parameterList,
+                body: body,
+                expressionBody: expressionBody,
+                semicolonToken: semicolonToken);
+        }
+
+        /// <summary>Creates a new OperatorDeclarationSyntax instance.</summary>
+        public static OperatorDeclarationSyntax OperatorDeclaration(
+            SyntaxList<AttributeListSyntax> attributeLists,
+            SyntaxTokenList modifiers,
+            TypeSyntax returnType,
+            SyntaxToken operatorToken,
+            ParameterListSyntax parameterList,
+            BlockSyntax? body,
+            ArrowExpressionClauseSyntax? expressionBody)
+        {
+            return SyntaxFactory.OperatorDeclaration(
+                attributeLists: attributeLists,
+                modifiers: modifiers,
+                returnType: returnType,
+                explicitInterfaceSpecifier: null,
+                operatorToken: operatorToken,
+                parameterList: parameterList,
+                body: body,
+                expressionBody: expressionBody);
+        }
+
         /// <summary>Creates a new UsingDirectiveSyntax instance.</summary>
         public static UsingDirectiveSyntax UsingDirective(NameEqualsSyntax alias, NameSyntax name)
         {
diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxFacts.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxFacts.cs
index 16e0365bcad28..4fc04e7e4efba 100644
--- a/src/Compilers/CSharp/Portable/Syntax/SyntaxFacts.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxFacts.cs
@@ -183,6 +183,9 @@ public static bool IsInTypeOnlyContext(ExpressionSyntax node)
                     case LocalFunctionStatement:
                         return ((LocalFunctionStatementSyntax)parent).ReturnType == node;
 
+                    case ParenthesizedLambdaExpression:
+                        return ((ParenthesizedLambdaExpressionSyntax)parent).ReturnType == node;
+
                     case SimpleBaseType:
                         return true;
 
diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs
index 5c1e743b646ce..24e70583c7166 100644
--- a/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs
@@ -859,5 +859,7 @@ public enum SyntaxKind : ushort
         RecordStructDeclaration = 9068,
 
         ExpressionColon = 9069,
+        LineDirectivePosition = 9070,
+        LineSpanDirectiveTrivia = 9071,
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs
index 00c44edd37bc8..9b51d4afad7d7 100644
--- a/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs
@@ -247,6 +247,7 @@ public static bool IsPreprocessorDirective(SyntaxKind kind)
                 case SyntaxKind.ErrorDirectiveTrivia:
                 case SyntaxKind.WarningDirectiveTrivia:
                 case SyntaxKind.LineDirectiveTrivia:
+                case SyntaxKind.LineSpanDirectiveTrivia:
                 case SyntaxKind.PragmaWarningDirectiveTrivia:
                 case SyntaxKind.PragmaChecksumDirectiveTrivia:
                 case SyntaxKind.ReferenceDirectiveTrivia:
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 0e383acc64ed0..547f235ce0b52 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -22,6 +22,11 @@
         <target state="translated">Konstruovaný obecný typ nejde vytvořit z jiného než obecného typu.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">{0}: abstraktní událost nemůže používat syntaxi přístupového objektu události.</target>
@@ -102,6 +107,36 @@
         <target state="translated">Asynchronní příkaz foreach nejde použít pro proměnné typu {0}, protože {0} neobsahuje veřejnou definici instance nebo rozšíření pro {1}. Měli jste v úmyslu foreach místo await foreach?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">V asynchronním příkazu foreach nejde použít kolekce dynamického typu.</target>
@@ -167,6 +202,11 @@
         <target state="translated">Chyba syntaxe příkazového řádku: {0} není platná hodnota možnosti {1}. Hodnota musí mít tvar {2}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">{0} musí odpovídat vlastnosti jenom pro inicializaci přepsaného člena {1}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist nemůže mít argument předávaný pomocí in nebo out</target>
@@ -222,6 +267,11 @@
         <target state="translated">Členy s názvem Clone se v záznamech nepovolují.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">{0} neimplementuje člen rozhraní {1}. {2} nemůže implementovat {1}.</target>
@@ -342,6 +392,11 @@
         <target state="translated">Vlastnost kontraktu rovnosti záznamu {0} musí mít přístupový objekt get.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">Explicitní použití System.Runtime.CompilerServices.NullableAttribute není povolené.</target>
@@ -367,6 +422,11 @@
         <target state="translated">Strom výrazu nemůže obsahovat hodnotu struktury REF ani zakázaný typ {0}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Strom výrazů nesmí obsahovat výraz indexu od-do (^).</target>
@@ -417,6 +477,11 @@
         <target state="translated">Funkce {0} je zkušební, a proto není podporovaná. K aktivaci použijte /features:{1}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">Funkce {0} není v C# 8.0 dostupná. Použijte prosím jazykovou verzi {1} nebo větší.</target>
@@ -462,6 +527,11 @@
         <target state="translated">Ukazatel na funkci se nedá zavolat s pojmenovanými argumenty.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">Vlastnosti instance v rozhraních nemůžou mít inicializátory.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">{0} nemůže implementovat člen rozhraní {1} v typu {2}, protože má parametr __arglist.</target>
@@ -657,6 +732,16 @@
         <target state="translated">Metoda {0} s blokem iterátoru musí být asynchronní, aby vrátila {1}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">Žádná přetížená metoda {0} neodpovídá ukazateli na funkci {1}.</target>
@@ -922,6 +1007,16 @@
         <target state="translated">Cílový modul runtime nepodporuje pro člena rozhraní přístupnost na úrovni Protected, Protected internal nebo Private protected.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">Cílový modul runtime nepodporuje rozšiřitelné konvence volání ani konvence volání výchozí pro prostředí modulu runtime.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">Pokud existuje jednotka kompilace s příkazy nejvyšší úrovně, nedá se zadat /main.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">Místní proměnná nebo místní funkce {0} deklarovaná v příkazu nejvyšší úrovně v tomto kontextu se nedá použít.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">{0} má atribut UnmanagedCallersOnly a nedá se převést na typ delegáta. Pro tuto metodu získejte ukazatel na funkci.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">kovariantní návratové hodnoty</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">UnmanagedCallersOnly se dá použít jen pro běžné statické metody nebo statické místní funkce.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">UnmanagedCallersOnly se dá použít jen pro běžné statické metody nebo statické místní funkce.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">Statický člen {0} nemůže být označený klíčovými slovy override, virtual nebo abstract.</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">Statický člen {0} nemůže být označený klíčovými slovy override, virtual nebo abstract.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ Pokud se taková třída používá jako základní třída a pokud odvozující
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">Uživatelem definovaný operátor nemůže převzít objekt nadřazeného typu a převést jej na objekt nadřazeného typu.</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">Uživatelem definovaný operátor nemůže převzít objekt nadřazeného typu a převést jej na objekt nadřazeného typu.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ Pokud se taková třída používá jako základní třída a pokud odvozující
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">{0} neimplementuje člen rozhraní {1}. {2} nemůže implementovat člen rozhraní, protože je statické.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">{0} neimplementuje člen rozhraní {1}. {2} nemůže implementovat člen rozhraní, protože je statické.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ Potlačení upozornění zvažte jenom v případě, když určitě nechcete če
         <target state="translated">Optimální přetěžovaná metoda Add {0} pro element inicializátoru kolekce je zastaralá. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Příkazy yield se nesmí objevit na horní úrovni v interaktivním kódu.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">Atribut zabezpečení {0} není platný u tohoto typu deklarace. Atributy zabezpečení jsou platné jenom u deklarací sestavení, typu a metody.</target>
@@ -10727,11 +10857,6 @@ Pokud chcete odstranit toto varování, můžete místo toho použít /reference
         <target state="translated">Aby se typ {0} mohl použít jako AsyncMethodBuilder pro typ {1}, měla by jeho vlastnost Task vracet typ {1} místo typu {2}.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">V parametrech místní funkce nebo v parametrech typu se atributy nepovolují.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">Modul {0} v sestavení {1} předává typ {2} několika sestavením: {3} a {4}.</target>
@@ -10983,8 +11108,8 @@ Pokud chcete odstranit toto varování, můžete místo toho použít /reference
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">Rozhraní nemůžou obsahovat operátory převodu, rovnosti nebo nerovnosti.</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">Rozhraní nemůžou obsahovat operátory převodu, rovnosti nebo nerovnosti.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ Pokud chcete odstranit toto varování, můžete místo toho použít /reference
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">{0} neimplementuje člen rozhraní {1}. {2} nemůže implicitně implementovat neveřejný člen rozhraní.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index e1d159bdafd18..b7bcb02850dfd 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -22,6 +22,11 @@
         <target state="translated">Es kann kein konstruierter generischer Typ aus einem nicht generischen Typ erstellt werden.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">{0}: Das abstrakte Ereignis kann die Ereignisaccessorsyntax nicht verwenden.</target>
@@ -102,6 +107,36 @@
         <target state="translated">Eine asynchrone foreach-Anweisung kann nicht für Variablen vom Typ "{0}" verwendet werden, weil "{0}" keine öffentliche Instanz- oder Erweiterungsdefinition für "{1}" enthält. Meinten Sie "foreach" statt "await foreach"?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">Eine Sammlung des dynamic-Typs kann in einem asynchronen foreach nicht verwendet werden.</target>
@@ -167,6 +202,11 @@
         <target state="translated">Fehler in der Befehlszeilensyntax: "{0}" ist kein gültiger Wert für die Option "{1}". Der Wert muss im Format "{2}" vorliegen.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">"{0}" muss mit der init-Zugriffsmethode des außer Kraft gesetzten Members "{1}" übereinstimmen.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">"__arglist" darf kein über "in" oder "out" übergebenes Argument umfassen.</target>
@@ -222,6 +267,11 @@
         <target state="translated">Member mit dem Namen "Clone" sind in Datensätzen nicht zulässig.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">Der Schnittstellenmember "{1}" wird von "{0}" nicht implementiert. "{1}" kann von "{2}" nicht implementiert werden.</target>
@@ -342,6 +392,11 @@
         <target state="translated">Die EqualityContract-Eigenschaft "{0}" für Datensätze muss eine get-Zugriffsmethode aufweisen.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">Die explizite Anwendung von "System.Runtime.CompilerServices.NullableAttribute" ist unzulässig.</target>
@@ -367,6 +422,11 @@
         <target state="translated">Eine Ausdrucksstruktur darf keinen Wert vom Typ "ref struct" oder vom eingeschränkten Typ "{0}" enthalten.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Eine Ausdrucksbaumstruktur darf keinen vom Ende ausgehenden Indexausdruck ("^") enthalten.</target>
@@ -417,6 +477,11 @@
         <target state="translated">Das Feature "{0}" ist experimentell und wird nicht unterstützt. Verwenden Sie zur Aktivierung "/features:{1}".</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">Das Feature "{0}" ist in C# 8.0 nicht verfügbar. Verwenden Sie Sprachversion {1} oder höher.</target>
@@ -462,6 +527,11 @@
         <target state="translated">Ein Funktionszeiger kann nicht mit benannten Argumenten aufgerufen werden.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">Instanzeigenschaften in Schnittstellen können keine Initialisierer aufweisen.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">"{0}" kann den Schnittstellenmember "{1}" in Typ "{2}" nicht implementieren, weil er einen __arglist-Parameter umfasst.</target>
@@ -657,6 +732,16 @@
         <target state="translated">Die Methode "{0}" mit einem Iteratorblock muss "async" lauten, um "{1}" zurückzugeben.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">Keine Überladung für "{0}" stimmt mit dem Funktionszeiger "{1}" überein.</target>
@@ -922,6 +1007,16 @@
         <target state="translated">Die Zugriffsoptionen "protected", "protected internal" oder "private protected" werden von der Zielruntime für einen Member einer Schnittstelle nicht unterstützt.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">Die Zielruntime unterstützt keine erweiterbaren Aufrufkonventionen oder Standardaufrufkonventionen der Runtime-Umgebung.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">"/main" kann nicht angegeben werden, wenn eine Kompilierungseinheit mit Anweisungen der obersten Ebene vorhanden ist.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">Die lokale Variable oder die lokale Funktion "{0}", die in einer Anweisung der obersten Ebene in diesem Kontext deklariert wurde, kann nicht verwendet werden.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">"{0}" ist mit dem Attribut "UnmanagedCallersOnly" versehen und kann nicht in einen Delegattyp konvertiert werden. Rufen Sie einen Funktionszeiger auf diese Methode ab.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">Covariante Rückgaben</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">"UnmanagedCallersOnly" kann nur auf normale statische Methoden oder statische lokale Funktionen angewendet werden.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">"UnmanagedCallersOnly" kann nur auf normale statische Methoden oder statische lokale Funktionen angewendet werden.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">Ein statischer Member "{0}" kann nicht als "override" , "virtual" oder "abstract" markiert werden.</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">Ein statischer Member "{0}" kann nicht als "override" , "virtual" oder "abstract" markiert werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ Wenn solch eine Klasse als Basisklasse verwendet wird und die ableitende Klasse
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">Ein benutzerdefinierter Operator kann kein Objekt vom einschließenden Typ übernehmen oder in ein Objekt des einschließenden Typs konvertieren.</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">Ein benutzerdefinierter Operator kann kein Objekt vom einschließenden Typ übernehmen oder in ein Objekt des einschließenden Typs konvertieren.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ Wenn solch eine Klasse als Basisklasse verwendet wird und die ableitende Klasse
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">"{0}" implementiert den Schnittstellenmember "{1}" nicht. "{2}" ist statisch und kann daher keinen Schnittstellenmember implementieren.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">"{0}" implementiert den Schnittstellenmember "{1}" nicht. "{2}" ist statisch und kann daher keinen Schnittstellenmember implementieren.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ Sie sollten das Unterdrücken der Warnung nur in Betracht ziehen, wenn Sie siche
         <target state="translated">Die beste überladene Add-Methode "{0}" für das Sammlungsinitialisiererelement ist veraltet. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Yield-Anweisungen dürfen nicht in der obersten Ebene von interaktivem Code enthalten sein.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">Das Sicherheitsattribut "{0}" ist für diesen Deklarationstyp nicht gültig. Sicherheitsattribute sind nur für Assembly-, Typ- und Methodendeklarationen gültig.</target>
@@ -10727,11 +10857,6 @@ Um die Warnung zu beheben, können Sie stattdessen /reference verwenden (Einbett
         <target state="translated">Damit der Typ "{0}" als "AsyncMethodBuilder" für den Typ "{1}" verwendet wird, muss seine Aufgabeneigenschaft den Typ "{1}" anstelle des Typs "{2}" zurückgeben.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">Attribute sind bei lokalen Funktionsparametern oder Typenparametern nicht zulässig.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">Das Modul "{0}" in der Assembly "{1}" leitet den Typ "{2}" an mehrere Assemblys weiter: "{3}" und "{4}".</target>
@@ -10983,8 +11108,8 @@ Um die Warnung zu beheben, können Sie stattdessen /reference verwenden (Einbett
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">Schnittstellen können keine Konvertierungs-, Gleichheits- oder Ungleichheitsoperatoren enthalten.</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">Schnittstellen können keine Konvertierungs-, Gleichheits- oder Ungleichheitsoperatoren enthalten.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ Um die Warnung zu beheben, können Sie stattdessen /reference verwenden (Einbett
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">Der Schnittstellenmember "{1}" wird von "{0}" nicht implementiert. Ein nicht öffentlicher Member kann von "{2}" nicht implizit implementiert werden.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index 4bebf58513d1d..a459337f27c8c 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -22,6 +22,11 @@
         <target state="translated">No se puede crear un tipo genérico construido a partir de un tipo no genérico.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">"{0}": un evento abstracto no puede usar la sintaxis de descriptor de acceso de eventos</target>
@@ -102,6 +107,36 @@
         <target state="translated">Una instrucción foreach asincrónica no puede funcionar en variables de tipo "{0}" porque "{0}" no contiene ninguna definición de extensión o instancia pública para "{1}". ¿Quiso decir “foreach” en lugar de “await foreach”?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">No se puede usar una colección de tipo dinámico en una instrucción foreach asincrónica.</target>
@@ -167,6 +202,11 @@
         <target state="translated">Error de sintaxis de la línea de comandos: "{0}" no es un valor válido para la opción "{1}". El valor debe tener el formato "{2}".</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">"{0}" debe coincidir por solo inicialización del miembro invalidado "{1}"</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist no puede tener un argumento que se ha pasado con "in" o "out"</target>
@@ -222,6 +267,11 @@
         <target state="translated">No se permiten los miembros denominados "Clone" en los registros.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">"{0}" no implementa el miembro de interfaz "{1}". "{2}" no puede implementar "{1}".</target>
@@ -342,6 +392,11 @@
         <target state="translated">La propiedad del contrato de igualdad de registros "{0}" debe tener un descriptor de acceso get.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">No se permite la aplicación explícita de "System.Runtime.CompilerServices.NullableAttribute".</target>
@@ -367,6 +422,11 @@
         <target state="translated">Un árbol de expresión no puede contener un valor de estructura ref ni el tipo restringido “{0}”.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Un árbol de expresión no puede contener una expresión de índice del otro extremo ("^").</target>
@@ -417,6 +477,11 @@
         <target state="translated">La característica "{0}" es experimental y no se admite. Use "/features:{1}" para habilitarla.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">La característica "{0}" no está disponible en C# 8.0. Use la versión {1} del lenguaje o una posterior.</target>
@@ -462,6 +527,11 @@
         <target state="translated">No se puede llamar a un puntero a función con argumentos con nombre.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">Las propiedades de la instancia en las interfaces no pueden tener inicializadores.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">“{0}” no puede implementar el miembro de interfaz “{1}” en el tipo “{2}” porque tiene un parámetro __arglist</target>
@@ -657,6 +732,16 @@
         <target state="translated">El método "{0}" con un bloqueo de iterador debe ser "asincrónico" para devolver "{1}"</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">Ninguna sobrecarga correspondiente a "{0}" coincide con el puntero de función "{1}".</target>
@@ -922,6 +1007,16 @@
         <target state="translated">El entorno de ejecución de destino no admite la accesibilidad protegida, protegida interna o protegida privada para un miembro de una interfaz.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">El entorno de ejecución de destino no admite convenciones de llamada predeterminadas de entorno en tiempo de ejecución o extensible.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">No se puede especificar /main si hay una unidad de compilación con instrucciones de nivel superior.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">No se puede usar la variable local ni la función local "{0}" declarada en una instrucción de nivel superior en este contexto.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">' {0} ' tiene un atributo ' UnmanagedCallersOnly ' y no se puede convertir en un tipo de delegado. Obtenga un puntero de función a este método.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">valores devueltos de covariante</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">"UnmanagedCallersOnly" solo se puede aplicar a las funciones locales estáticas o los métodos estáticos ordinarios.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">"UnmanagedCallersOnly" solo se puede aplicar a las funciones locales estáticas o los métodos estáticos ordinarios.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">Un miembro estático '{0}' no se puede marcar como invalidación, virtual o abstracto</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">Un miembro estático '{0}' no se puede marcar como invalidación, virtual o abstracto</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ Si se utiliza una clase de este tipo como clase base y si la clase derivada defi
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">Un operador definido por el usuario no puede adquirir un objeto de tipo envolvente ni convertirlo en un objeto de tipo envolvente</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">Un operador definido por el usuario no puede adquirir un objeto de tipo envolvente ni convertirlo en un objeto de tipo envolvente</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ Si se utiliza una clase de este tipo como clase base y si la clase derivada defi
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">'{0}' no implementa el miembro de interfaz '{1}'. '{2}' no puede implementar un miembro de interfaz porque es estático.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">'{0}' no implementa el miembro de interfaz '{1}'. '{2}' no puede implementar un miembro de interfaz porque es estático.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ Considere la posibilidad de suprimir la advertencia solo si tiene la seguridad d
         <target state="translated">El mejor método Add sobrecargado '{0}' para el elemento inicializador de la colección está obsoleto. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Las instrucciones yield pueden no aparecer en el nivel superior del código interactivo.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">El valor '{0}' de SecurityAction no es válido en este tipo de declaración. Los atributos de seguridad solo son válidos en las declaraciones de ensamblado, de tipo y de método.</target>
@@ -10727,11 +10857,6 @@ Para eliminar la advertencia puede usar /reference (establezca la propiedad Embe
         <target state="translated">Para que el tipo "{0}" se utilice como AsyncMethodBuilder para el tipo "{1}", su propiedad Task debe devolver el tipo "{1}" en lugar del tipo "{2}".</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">No se permiten atributos en los parámetros de tipo o parámetros de funciones locales.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">El módulo "{0}" del ensamblado "{1}" va a reenviar el tipo "{2}" a varios ensamblados: "{3}" y "{4}".</target>
@@ -10983,8 +11108,8 @@ Para eliminar la advertencia puede usar /reference (establezca la propiedad Embe
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">Las interfaces no pueden contener operadores de conversión, igualdad o desigualdad</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">Las interfaces no pueden contener operadores de conversión, igualdad o desigualdad</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ Para eliminar la advertencia puede usar /reference (establezca la propiedad Embe
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">"{0}" no implementa el miembro de interfaz "{1}". "{2}" no puede implementar implícitamente un miembro que no sea público.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index abce2a04fb22a..a653f76613e4b 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -22,6 +22,11 @@
         <target state="translated">Impossible de créer un type générique construit à partir d'un type non générique.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">'{0}' : un événement abstrait ne peut pas utiliser une syntaxe d'accesseur d'événement</target>
@@ -102,6 +107,36 @@
         <target state="translated">L'instruction foreach asynchrone ne peut pas fonctionner sur des variables de type '{0}', car '{0}' ne contient pas de définition d'extension ou d'instance publique pour '{1}'. Vouliez-vous dire 'foreach' plutôt que 'await foreach' ?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">Impossible d'utiliser une collection de type dynamique dans un foreach asynchrone</target>
@@ -167,6 +202,11 @@
         <target state="translated">Erreur de syntaxe de ligne de commande : '{0}' est une valeur non valide pour l'option '{1}'. La valeur doit se présenter sous la forme '{2}'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">'{0}' doit correspondre par initialisation uniquement au membre substitué '{1}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist ne peut pas avoir un argument passé par 'in' ou 'out'</target>
@@ -222,6 +267,11 @@
         <target state="translated">Les membres nommés 'Clone' ne sont pas autorisés dans les enregistrements.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">'{0}' n'implémente pas le membre d'interface '{1}'. '{2}' ne peut pas implémenter '{1}'.</target>
@@ -342,6 +392,11 @@
         <target state="translated">La propriété de contrat d'égalité d'enregistrement '{0}' doit avoir un accesseur get.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">L'application explicite de 'System.Runtime.CompilerServices.NullableAttribute' n'est pas autorisée.</target>
@@ -367,6 +422,11 @@
         <target state="translated">Une arborescence de l'expression ne peut pas contenir de valeur de struct par référence ou de type restreint '{0}'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Une arborescence de l'expression ne peut pas contenir d'expression d'index partant de la fin ('^').</target>
@@ -417,6 +477,11 @@
         <target state="translated">La fonctionnalité '{0}' est expérimentale et non prise en charge. Utilisez '/features:{1}' pour l'activer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">La fonctionnalité '{0}' n'est pas disponible en C# 8.0. Utilisez la version de langage {1} ou une version ultérieure.</target>
@@ -462,6 +527,11 @@
         <target state="translated">Impossible d'appeler un pointeur de fonction avec des arguments nommés.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">Les propriétés d'instance dans les interfaces ne peuvent pas avoir d'initialiseurs.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">'{0}' ne peut pas implémenter le membre d'interface '{1}' dans le type '{2}', car il a un paramètre __arglist</target>
@@ -657,6 +732,16 @@
         <target state="translated">La méthode '{0}' avec un bloc itérateur doit être 'async' pour retourner '{1}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">Aucune surcharge pour '{0}' ne correspond au pointeur de fonction '{1}'</target>
@@ -922,6 +1007,16 @@
         <target state="translated">Le runtime cible ne prend pas en charge l'accessibilité 'protected', 'protected internal' ou 'private protected' d'un membre d'interface.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">Le runtime cible ne prend pas en charge les conventions d'appel par défaut des environnements extensibles ou d'exécution.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">Impossible de spécifier /main s'il existe une unité de compilation avec des instructions de niveau supérieur.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">Impossible d'utiliser une variable locale ou une fonction locale '{0}' déclarée dans une instruction de niveau supérieur dans ce contexte.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">'{0}' est attribué avec 'UnmanagedCallersOnly' et ne peut pas être converti en type délégué. Obtenez un pointeur de fonction vers cette méthode.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">retours covariants</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">'UnmanagedCallersOnly' peut uniquement être appliqué aux méthodes statiques ordinaires ou aux fonctions locales statiques.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">'UnmanagedCallersOnly' peut uniquement être appliqué aux méthodes statiques ordinaires ou aux fonctions locales statiques.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">Un membre statique '{0}' ne peut pas être marqué comme override, virtual ou abstract</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">Un membre statique '{0}' ne peut pas être marqué comme override, virtual ou abstract</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ Si une telle classe est utilisée en tant que classe de base et si la classe dé
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">L'opérateur défini par l'utilisateur ne peut pas prendre un objet du type englobant et le convertir en un objet du type englobant</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">L'opérateur défini par l'utilisateur ne peut pas prendre un objet du type englobant et le convertir en un objet du type englobant</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ Si une telle classe est utilisée en tant que classe de base et si la classe dé
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">'{0}' n'implémente pas le membre d'interface '{1}'. '{2}' ne peut pas implémenter un membre d'interface, car il est static.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">'{0}' n'implémente pas le membre d'interface '{1}'. '{2}' ne peut pas implémenter un membre d'interface, car il est static.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ Supprimez l'avertissement seulement si vous êtes sûr de ne pas vouloir attendr
         <target state="translated">La meilleure méthode Add surchargée '{0}' pour l'élément initialiseur de collection est obsolète. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Les instructions yield ne peuvent pas figurer au niveau supérieur dans le code interactif.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">L'attribut de sécurité '{0}' n'est pas valide dans ce type de déclaration. Les attributs de sécurité ne sont valides que dans les déclarations d'assembly, de type et de méthode.</target>
@@ -10727,11 +10857,6 @@ Pour supprimer l'avertissement, vous pouvez utiliser la commande /reference (dé
         <target state="translated">Pour que le type '{0}' soit utilisé comme AsyncMethodBuilder du type '{1}', sa propriété Task doit retourner le type '{1}' à la place du type '{2}'.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">Les attributs ne sont pas autorisés sur les paramètres de fonction locale ou les paramètres de type</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">Le module '{0}' dans l'assembly '{1}' transfère le type '{2}' à plusieurs assemblys : '{3}' et '{4}'.</target>
@@ -10983,8 +11108,8 @@ Pour supprimer l'avertissement, vous pouvez utiliser la commande /reference (dé
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">Les interfaces ne peuvent pas contenir d'opérateurs de conversion, d'égalité ou d'inégalité</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">Les interfaces ne peuvent pas contenir d'opérateurs de conversion, d'égalité ou d'inégalité</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ Pour supprimer l'avertissement, vous pouvez utiliser la commande /reference (dé
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">'{0}' n'implémente pas le membre d'interface '{1}'. '{2}' ne peut pas implémenter implicitement un membre non public.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 4e4b8aff159a1..60dd3069b87f6 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -22,6 +22,11 @@
         <target state="translated">Non è possibile creare un tipo generico costruito a partire da un tipo non generico.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">'{0}': l'evento astratto non può usare la sintassi della funzione di accesso agli eventi</target>
@@ -102,6 +107,36 @@
         <target state="translated">L'istruzione foreach asincrona non può funzionare con variabili di tipo '{0}' perché '{0}' non contiene una definizione di istanza o estensione pubblica per '{1}'. Si intendeva 'foreach' invece di 'await foreach'?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">Non è possibile usare una raccolta di tipo dinamico in un'istruzione foreach asincrona</target>
@@ -167,6 +202,11 @@
         <target state="translated">Errore di sintassi della riga di comando: '{0}' non è un valore valido per l'opzione '{1}'. Il valore deve essere espresso nel formato '{2}'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">'{0}' deve corrispondere per sola inizializzazione del membro '{1}' di cui è stato eseguito l'override</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist non può contenere un argomento passato da 'in' o 'out'</target>
@@ -222,6 +267,11 @@
         <target state="translated">Nei record non sono consentiti membri denominati 'Clone'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">'{0}' non implementa il membro di interfaccia '{1}'. '{2}' non può implementare '{1}'.</target>
@@ -342,6 +392,11 @@
         <target state="translated">La proprietà '{0}' del contratto di uguaglianza record deve contenere una funzione di accesso get.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">L'applicazione esplicita di 'System.Runtime.CompilerServices.NullableAttribute' non è consentita.</target>
@@ -367,6 +422,11 @@
         <target state="translated">L'albero delle espressioni non può contenere il valore '{0}' per lo struct ref o il tipo limitato.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Un albero delle espressioni non può contenere un'espressione di indice from end ('^').</target>
@@ -417,6 +477,11 @@
         <target state="translated">La funzionalità '{0}' è sperimentale e non è supportata. Per abilitare, usare '/features:{1}'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">La funzionalità '{0}' non è disponibile in C# 8.0. Usare la versione {1} o versioni successive del linguaggio.</target>
@@ -462,6 +527,11 @@
         <target state="translated">Non è possibile chiamare un puntatore a funzione con argomenti denominati.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">Le proprietà di istanza nelle interfacce non possono avere inizializzatori.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">'{0}' non può implementare il membro di interfaccia '{1}' nel tipo '{2}' perché contiene un parametro __arglist</target>
@@ -657,6 +732,16 @@
         <target state="translated">Il metodo '{0}' con un blocco iteratore deve essere 'async' per restituire '{1}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">Nessun overload per '{0}' corrisponde al puntatore a funzione '{1}'</target>
@@ -922,6 +1007,16 @@
         <target state="translated">Il runtime di destinazione non supporta l'accessibilità 'protected', 'protected internal' o 'private protected' per un membro di un'interfaccia.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">Il runtime di destinazione non supporta convenzioni di chiamata predefinite estendibili o dell'ambiente di runtime.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">Non è possibile specificare /main se è presente un'unità di compilazione con istruzioni di primo livello.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">In questo contesto non è possibile usare la variabile locale o la funzione locale '{0}' dichiarata in un'istruzione di primo livello.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">'{0}', a cui è assegnato l'attributo 'UnmanagedCallersOnly', non può essere convertito in un tipo delegato. Ottenere un puntatore a funzione per questo metodo.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">tipi restituiti covarianti</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">'UnmanagedCallersOnly' può essere applicato solo a metodi statici normali o funzioni locali statiche.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">'UnmanagedCallersOnly' può essere applicato solo a metodi statici normali o funzioni locali statiche.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">Un membro statico '{0}' non può essere contrassegnato come override, virtual o abstract</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">Un membro statico '{0}' non può essere contrassegnato come override, virtual o abstract</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ Se si usa tale classe come classe base e se la classe di derivazione definisce u
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">L'operatore definito dall'utente non può accettare un oggetto del tipo di inclusione e convertirlo in un oggetto del tipo di inclusione</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">L'operatore definito dall'utente non può accettare un oggetto del tipo di inclusione e convertirlo in un oggetto del tipo di inclusione</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ Se si usa tale classe come classe base e se la classe di derivazione definisce u
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">'{0}' non implementa il membro di interfaccia '{1}'. '{2}' non può implementare un membro di interfaccia perché è di tipo statico.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">'{0}' non implementa il membro di interfaccia '{1}'. '{2}' non può implementare un membro di interfaccia perché è di tipo statico.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ Come procedura consigliata, è consigliabile attendere sempre la chiamata.
         <target state="translated">Il miglior metodo Add di overload '{0}' per l'elemento inizializzatore di raccolta è obsoleto. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Le istruzioni yield potrebbero non apparire al primo livello del codice interattivo.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">L'attributo di sicurezza '{0}' non è valido in questo tipo di dichiarazione. Gli attributi di sicurezza sono validi solo in dichiarazioni di metodo, assembly e tipi.</target>
@@ -10727,11 +10857,6 @@ Per rimuovere l'avviso, è invece possibile usare /reference (impostare la propr
         <target state="translated">La proprietà Task del tipo '{0}' da usare come elemento AsyncMethodBuilder per il tipo '{1}' deve restituire il tipo '{1}' invece di '{2}'.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">Gli attributi non sono consentiti in parametri di funzione locali o parametri di tipo</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">Il modulo '{0}' nell'assembly '{1}' inoltra il tipo '{2}' a più assembly '{3}' e '{4}'.</target>
@@ -10983,8 +11108,8 @@ Per rimuovere l'avviso, è invece possibile usare /reference (impostare la propr
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">Le interfacce non possono contenere operatori di conversione, uguaglianza o disuguaglianza</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">Le interfacce non possono contenere operatori di conversione, uguaglianza o disuguaglianza</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ Per rimuovere l'avviso, è invece possibile usare /reference (impostare la propr
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">'{0}' non implementa il membro di interfaccia '{1}'. '{2}' non può implementare implicitamente un membro non pubblico.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index 6b92390b45e0e..2a397841e2ed9 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -22,6 +22,11 @@
         <target state="translated">非ジェネリック型から、構築済みジェネリック型を作成できません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">'{0}': 抽象イベントはイベント アクセサーの構文を使用できません</target>
@@ -102,6 +107,36 @@
         <target state="translated">'{0}' は '{1}' のパブリック インスタンスまたは拡張機能の定義を含んでいないため、型 '{0}' の変数に対して非同期 foreach ステートメントを使用することはできません。'await foreach' ではなく 'foreach' ですか?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">非同期 foreach では動的な型のコレクションを使用できません</target>
@@ -167,6 +202,11 @@
         <target state="translated">コマンドライン構文エラー: '{0}' は、'{1}' オプションの有効な値ではありません。値は '{2}' の形式にする必要があります。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">'{0}' は、オーバーライドされたメンバー '{1}' と同じく、初期化専用である必要があります</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist では、'in' や 'out' で引数を渡すことができません</target>
@@ -222,6 +267,11 @@
         <target state="translated">'Clone' という名前のメンバーはレコードでは許可されていません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">'{0}' は、インターフェイス メンバー '{1}' を実装していません。'{2}' は '{1}' を実装できません。</target>
@@ -342,6 +392,11 @@
         <target state="translated">レコードの等値コントラクト プロパティ '{0}' には get アクセサーが必要です。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">'System.Runtime.CompilerServices.NullableAttribute' の明示的な適用は許可されていません。</target>
@@ -367,6 +422,11 @@
         <target state="translated">式ツリーに ref 構造体または制限がある型 '{0}' の値を含めることはできません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">式ツリーに、from-end インデックス ('^') 式を含めることはできません。</target>
@@ -417,6 +477,11 @@
         <target state="translated">機能 '{0}' は試験段階であり、サポートされていません。有効にするには '/features:{1}' をご使用ください。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">機能 '{0}' は C# 8.0 では使用できません。言語バージョン {1} 以上を使用してください。</target>
@@ -462,6 +527,11 @@
         <target state="translated">関数ポインターを名前付き引数で呼び出すことはできません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">インターフェイス内のインスタンス プロパティは初期化子を持つことができません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">'{0}' は、__arglist パラメーターが指定されているため、型 '{2}' のインターフェイス メンバー '{1}' を実装できません</target>
@@ -657,6 +732,16 @@
         <target state="translated">反復子ブロックを伴うメソッド '{0}' が '{1}' を返すには 'async' でなければなりません</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">関数ポインター '{1}' に一致する '{0}' のオーバーロードはありません</target>
@@ -922,6 +1007,16 @@
         <target state="translated">ターゲット ランタイムは、インターフェイスのメンバーに対して 'protected'、'protected internal'、'private protected' アクセシビリティをサポートしていません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">ターゲット ランタイムは、拡張可能またはランタイム環境の既定の呼び出し規則をサポートしていません。</target>
@@ -942,6 +1037,11 @@
         <target state="translated">トップレベルのステートメントを含むコンパイル ユニットがある場合、/main を指定することはできません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">このコンテキストでは、トップレベルのステートメントで宣言されたローカル変数またはローカル関数 '{0}' を使用することはできません。</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">'{0}' は 'UnmanagedCallersOnly' 属性が設定されているため、デリゲート型に変換できません。このメソッドへの関数ポインターを取得してください。</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">covariant の戻り値</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">'UnmanagedCallersOnly' は、通常の静的メソッドまたは静的ローカル関数にのみ適用できます。</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">'UnmanagedCallersOnly' は、通常の静的メソッドまたは静的ローカル関数にのみ適用できます。</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">静的メンバー '{0}' を override、virtual、または abstract とすることはできません</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">静的メンバー '{0}' を override、virtual、または abstract とすることはできません</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">'{0}' は、インターフェイス メンバー '{1}' を実装していません。'{2}' は static のため、インターフェイス メンバーを実装できません。</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">'{0}' は、インターフェイス メンバー '{1}' を実装していません。'{2}' は static のため、インターフェイス メンバーを実装できません。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ You should consider suppressing the warning only if you're sure that you don't w
         <target state="translated">コレクション初期化子要素に最も適しているオーバーロード Add メソッド '{0}' は古い形式です。{1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Yield ステートメントは、対話型コードの最上部に表示できません。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">セキュリティ属性 '{0}' はこの宣言型では無効です。セキュリティ属性は、アセンブリ、型、メソッドの宣言でのみ有効です。</target>
@@ -10727,11 +10857,6 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <target state="translated">型 '{0}' を型 '{1}' の AsyncMethodBuilder として使うには、その Task プロパティが型 '{2}' ではなく型 '{1}' を返す必要があります。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">ローカル関数パラメーターまたは型パラメーターに属性を使うことはできません</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">アセンブリ '{1}' のモジュール '{0}' によって、型 '{2}' が複数のアセンブリ '{3}' および '{4}' に転送されています。</target>
@@ -10983,8 +11108,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">インターフェイスには、変換演算子、等値演算子、非等値演算子を含めることはできません</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">インターフェイスには、変換演算子、等値演算子、非等値演算子を含めることはできません</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">'{0}' は、インターフェイス メンバー '{1}' を実装していません。'{2}' はパブリックでないメンバーを暗黙的に実装できません。</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 92edb8e927962..27116b8802263 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -22,6 +22,11 @@
         <target state="translated">제네릭이 아닌 형식에서 생성된 제네릭 형식을 만들 수 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">'{0}': 추상 이벤트는 이벤트 접근자 구문을 사용할 수 없습니다.</target>
@@ -102,6 +107,36 @@
         <target state="translated">'{0}' 형식 변수에서 비동기 foreach 문을 수행할 수 없습니다. '{0}'에는 '{1}'의 공개 인스턴스 또는 확장 정의가 없기 때문입니다. 'await foreach' 대신 'foreach'를 사용하시겠습니까?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">비동기 foreach에는 동적 형식 컬렉션을 사용할 수 없습니다.</target>
@@ -167,6 +202,11 @@
         <target state="translated">명령줄 구문 오류: '{0}'은(는) '{1}' 옵션에 유효한 값이 아닙니다. 값은 '{2}' 형식이어야 합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">'{0}'은(는) 재정의된 멤버 '{1}'의 초기화 전용으로 일치해야 합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist는 'in' 또는 'out'으로 전달되는 인수를 가질 수 없습니다.</target>
@@ -222,6 +267,11 @@
         <target state="translated">'Clone'이라는 멤버는 레코드에서 허용되지 않습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">'{0}'은(는) 인터페이스 멤버 '{1}'을(를) 구현하지 않습니다. '{2}'은(는) '{1}'을(를) 구현할 수 없습니다.</target>
@@ -342,6 +392,11 @@
         <target state="translated">레코드 같음 계약 속성 '{0}'에는 get 접근자가 있어야 합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">'System.Runtime.CompilerServices.NullableAttribute'의 명시적 적용은 허용되지 않습니다.</target>
@@ -367,6 +422,11 @@
         <target state="translated">식 트리에는 ref struct 값 또는 제한된 형식 '{0}'을(를) 사용할 수 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">식 트리에는 내림차순 인덱스('^') 식을 포함할 수 없습니다.</target>
@@ -417,6 +477,11 @@
         <target state="translated">기능 '{0}'은(는) 실험적이며 지원되지 않습니다. 사용하도록 설정하려면 '/features:{1}'을(를) 사용하세요.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">'{0}' 기능은 C# 8.0에서 사용할 수 없습니다. 언어 버전 {1} 이상을 사용하세요.</target>
@@ -462,6 +527,11 @@
         <target state="translated">함수 포인터는 명명된 인수를 사용하여 호출할 수 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">인터페이스의 인스턴스 속성은 이니셜라이저를 사용할 수 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">'{0}'은(는) __arglist 매개 변수가 있으므로 '{2}' 형식의 인터페이스 멤버 '{1}'을(를) 구현할 수 없습니다.</target>
@@ -657,6 +732,16 @@
         <target state="translated">'{1}'을(를) 반환하려면 반복기 블록이 있는 '{0}' 메서드가 '비동기'여야 합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">함수 포인터 '{1}'과(와) 일치하는 '{0}'에 대한 오버로드가 없습니다.</target>
@@ -922,6 +1007,16 @@
         <target state="translated">대상 런타임이 인터페이스 멤버의 'protected', 'protected internal' 또는 'private protected' 접근성을 지원하지 않습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">대상 런타임에서 확장 가능 또는 런타임 환경 기본 호출 규칙을 지원하지 않습니다.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">최상위 문이 포함된 컴파일 단위가 있으면 /main을 지정할 수 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">이 컨텍스트에서는 최상위 문에 선언된 지역 변수 또는 로컬 함수 '{0}'을(를) 사용할 수 없습니다.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">'{0}'에는 'UnmanagedCallersOnly' 특성이 지정되어 있으며 이 항목은 대리자 형식으로 변환할 수 없습니다. 이 메서드에 대한 함수 포인터를 가져오세요.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">공변(covariant) 반환</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">'UnmanagedCallersOnly'는 일반 정적 메서드 또는 정적 로컬 함수에만 적용할 수 있습니다.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">'UnmanagedCallersOnly'는 일반 정적 메서드 또는 정적 로컬 함수에만 적용할 수 있습니다.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3626,8 +3761,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">'{0}' 정적 멤버는 override, virtual 또는 abstract로 표시할 수 없습니다.</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">'{0}' 정적 멤버는 override, virtual 또는 abstract로 표시할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5170,8 +5305,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">사용자 정의 연산자는 바깥쪽 형식의 개체를 가져와서 바깥쪽 형식의 개체로 변환할 수 없습니다.</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">사용자 정의 연산자는 바깥쪽 형식의 개체를 가져와서 바깥쪽 형식의 개체로 변환할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5940,8 +6075,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">'{0}'은(는) '{1}' 인터페이스 멤버를 구현하지 않습니다. '{2}'은(는) static이므로 인터페이스 멤버를 구현할 수 없습니다.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">'{0}'은(는) '{1}' 인터페이스 멤버를 구현하지 않습니다. '{2}'은(는) static이므로 인터페이스 멤버를 구현할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9193,11 +9328,6 @@ You should consider suppressing the warning only if you're sure that you don't w
         <target state="translated">오버로드된 Add 메서드 중 해당 컬렉션 이니셜라이저 요소에 가장 적합한 '{0}'은(는) 사용되지 않습니다. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Yield 문이 대화형 코드의 최상위 수준에 표시되지 않을 수 있습니다.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">이 선언 형식에서는 '{0}' 보안 특성이 유효하지 않습니다. 보안 특성은 어셈블리, 형식 및 메서드 선언에서만 유효합니다.</target>
@@ -10726,11 +10856,6 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <target state="translated">'{1}' 형식에 대한 AsyncMethodBuilder로 사용할 '{0}' 형식의 작업 속성은 '{2}' 형식 대신 '{1}' 형식을 반환해야 합니다.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">특성은 로컬 함수 매개 변수 또는 형식 매개 변수에서 사용할 수 없습니다.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">'{1}' 어셈블리의 '{0}' 모듈이 여러 어셈블리 '{3}' 및 '{4}'에 '{2}' 형식을 전달하고 있습니다.</target>
@@ -10982,8 +11107,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">인터페이스에는 변환, 같음 또는 같지 않음 연산자가 포함될 수 없습니다.</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">인터페이스에는 변환, 같음 또는 같지 않음 연산자가 포함될 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10997,8 +11122,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">'{0}'은(는) 인터페이스 멤버 '{1}'을(를) 구현하지 않습니다. '{2}'은(는) public이 아닌 멤버를 암시적으로 구현할 수 없습니다.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index c65cba99c2aee..68e36282b73bb 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -22,6 +22,11 @@
         <target state="translated">Nie można utworzyć konstruowanego typu ogólnego z typu nieogólnego.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">„{0}”: zdarzenie abstrakcyjne nie może używać składni metody dostępu zdarzenia</target>
@@ -102,6 +107,36 @@
         <target state="translated">Asynchroniczna instrukcja foreach nie może operować na zmiennych typu „{0}”, ponieważ typ „{0}” nie zawiera publicznego wystąpienia lub definicji rozszerzenia dla elementu „{1}”. Czy planowano użyć instrukcji „foreach”, a nie „await foreach”?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">Nie można użyć kolekcji typu dynamicznego w asynchronicznej instrukcji foreach</target>
@@ -167,6 +202,11 @@
         <target state="translated">Błąd składni wiersza polecenia: „{0}” nie jest prawidłową wartością dla opcji „{1}”. Wartość musi mieć postać „{2}”.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">Element „{0}” musi odpowiadać zmiennymi tylko do inicjowania przesłoniętej składowej „{1}”</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">Element __arglist nie może mieć argumentu przekazywanego przez parametr „in” ani „out”</target>
@@ -222,6 +267,11 @@
         <target state="translated">Składowe o nazwie „Clone” są niedozwolone w rekordach.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">Element „{0}” nie implementuje składowej interfejsu „{1}”. Element „{2}” nie może implementować elementu „{1}”.</target>
@@ -342,6 +392,11 @@
         <target state="translated">Właściwość kontraktu równości rekordu „{0}” musi mieć metodę dostępu get.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">Jawne stosowanie elementu „System.Runtime.CompilerServices.NullableAttribute” jest niedozwolone.</target>
@@ -367,6 +422,11 @@
         <target state="translated">Drzewo wyrażeń nie może zawierać wartości elementu ref struct ani typu ograniczonego „{0}”.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Drzewo wyrażeń nie może zawierać wyrażenia „od końca indeksu” („^”).</target>
@@ -417,6 +477,11 @@
         <target state="translated">Funkcja „{0}” jest eksperymentalna i nieobsługiwana. Aby ją włączyć, użyj parametru „/features:{1}”.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">Funkcja „{0}” nie jest dostępna w języku C# 8.0. Użyj języka w wersji {1} lub nowszej.</target>
@@ -462,6 +527,11 @@
         <target state="translated">Nie można wywołać wskaźnika funkcji przy użyciu argumentów nazwanych.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">Właściwości wystąpienia w interfejsach nie mogą mieć inicjatorów.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">Obiekt „{0}” nie może implementować elementu członkowskiego interfejsu „{1}” w ramach typu „{2}”, ponieważ zawiera on parametr __arglist</target>
@@ -657,6 +732,16 @@
         <target state="translated">Metoda „{0}” z blokiem iteratora musi być oznaczona jako „async”, aby zwrócić „{1}”</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">Żadne z przeciążeń dla elementu „{0}” nie pasuje do wskaźnika funkcji „{1}”</target>
@@ -922,6 +1007,16 @@
         <target state="translated">Docelowe środowisko uruchomieniowe nie obsługuje specyfikatorów dostępu „protected”, „protected internal” i „private protected” dla składowej interfejsu.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">Docelowe środowisko uruchomieniowe nie obsługuje rozszerzalnych ani domyślnych dla środowiska uruchomieniowego konwencji wywoływania.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">Nie można określić opcji /main, jeśli istnieje jednostka kompilacji z instrukcjami najwyższego poziomu.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">W tym kontekście nie można użyć zmiennej lokalnej ani funkcji lokalnej „{0}” zadeklarowanej w instrukcji najwyższego poziomu.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">Element „{0}” ma atrybut „UnmanagedCallersOnly” i nie można go przekonwertować na typ delegowany. Uzyskaj wskaźnik funkcji do tej metody.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">zwroty kowariantne</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">Atrybut „UnmanagedCallersOnly” może być stosowany tylko do zwykłych metod statycznych lub statycznych funkcji lokalnych.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">Atrybut „UnmanagedCallersOnly” może być stosowany tylko do zwykłych metod statycznych lub statycznych funkcji lokalnych.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">Statycznej składowej „{0}” nie można oznaczyć specyfikatorem override, virtual ani abstract</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">Statycznej składowej „{0}” nie można oznaczyć specyfikatorem override, virtual ani abstract</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ Jeśli taka klasa zostanie użyta jako klasa bazowa i klasa pochodna definiuje d
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">Zdefiniowany przez użytkownika operator nie może pobrać obiektu typu otaczającego i dokonać konwersji na obiekt typu otaczającego</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">Zdefiniowany przez użytkownika operator nie może pobrać obiektu typu otaczającego i dokonać konwersji na obiekt typu otaczającego</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ Jeśli taka klasa zostanie użyta jako klasa bazowa i klasa pochodna definiuje d
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">'Element „{0}” nie implementuje składowej interfejsu „{1}”. Element „{2}” nie może implementować składowej interfejsu, ponieważ jest statyczna.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">'Element „{0}” nie implementuje składowej interfejsu „{1}”. Element „{2}” nie może implementować składowej interfejsu, ponieważ jest statyczna.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ Pominięcie ostrzeżenia należy wziąć pod uwagę tylko w sytuacji, gdy na pew
         <target state="translated">Najlepsza przeciążona metoda Add „{0}” dla elementu inicjatora kolekcji jest przestarzała. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Instrukcje yield nie mogą pojawiać się na najwyższym poziomie kodu interaktywnego.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">Atrybut zabezpieczeń „{0}” jest nieprawidłowy w tym typie deklaracji. Atrybuty zabezpieczeń są prawidłowe tylko dla deklaracji zestawu, typu i metody.</target>
@@ -10727,11 +10857,6 @@ Aby usunąć ostrzeżenie, możesz zamiast tego użyć opcji /reference (ustaw w
         <target state="translated">Aby typ „{0}” mógł zostać użyty jako element AsyncMethodBuilder dla typu „{1}”, jego właściwość zadania powinna zwracać typ „{1}” zamiast typu „{2}”.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">Atrybuty nie są dozwolone w przypadku lokalnych parametrów funkcji lub parametrów typu</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">Moduł „{0}” w zestawie „{1}” przekazuje typ „{2}” do wielu zestawów: „{3}” i „{4}”.</target>
@@ -10983,8 +11108,8 @@ Aby usunąć ostrzeżenie, możesz zamiast tego użyć opcji /reference (ustaw w
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">Interfejsy nie mogą zawierać operatorów konwersji, równości ani nierówności</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">Interfejsy nie mogą zawierać operatorów konwersji, równości ani nierówności</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ Aby usunąć ostrzeżenie, możesz zamiast tego użyć opcji /reference (ustaw w
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">Element „{0}” nie implementuje składowej interfejsu „{1}”. Element „{2}” nie może jawnie implementować składowej niepublicznej.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index 72406042d8b5e..d298b1691a59f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -22,6 +22,11 @@
         <target state="translated">Não é possível criar um tipo genérico construído com base em um tipo não genérico.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">'{0}': o evento abstrato não pode usar a sintaxe do acessador de eventos</target>
@@ -102,6 +107,36 @@
         <target state="translated">A instrução foreach assíncrona não pode operar em variáveis do tipo '{0}' porque '{0}' não contém uma definição de extensão ou de instância pública para '{1}'. Você quis dizer 'foreach' em vez de 'await foreach'?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">Não é possível usar uma coleção do tipo dinâmico em uma foreach assíncrona</target>
@@ -167,6 +202,11 @@
         <target state="translated">Erro de sintaxe de linha de comando: '{0}' não é um valor válido para a opção '{1}'. O valor precisa estar no formato '{2}'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">'{0}' precisa corresponder por somente de inicialização do membro substituído '{1}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist não pode ter um argumento passado por 'in' ou 'out'</target>
@@ -222,6 +267,11 @@
         <target state="translated">Os membros chamados 'Clone' não são permitidos nos registros.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">'{0}' não implementa o membro de interface '{1}'. '{2}' não pode implementar '{1}'.</target>
@@ -342,6 +392,11 @@
         <target state="translated">A propriedade de contrato de igualdade do registro '{0}' precisa ter um acessador get.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">Não é permitida a aplicação explícita de 'System.Runtime.CompilerServices.NullableAttribute'.</target>
@@ -367,6 +422,11 @@
         <target state="translated">A árvore de expressão não pode conter um valor de struct de referência ou o tipo restrito '{0}'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Uma árvore de expressão não pode conter uma expressão de índice de front-end ('^').</target>
@@ -417,6 +477,11 @@
         <target state="translated">O recurso '{0}' é experimental e sem suporte; use '/features:{1}' para habilitar.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">O recurso '{0}' não está disponível em C# 8.0. Use a versão de linguagem {1} ou superior.</target>
@@ -462,6 +527,11 @@
         <target state="translated">Um ponteiro de função não pode ser chamado com argumentos nomeados.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">As propriedades da instância nas interfaces não podem ter inicializadores.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">'{0}' não pode implementar o membro de interface '{1}' no tipo '{2}' porque tem um parâmetro __arglist</target>
@@ -657,6 +732,16 @@
         <target state="translated">O método '{0}' com um bloco do iterador deve ser 'async' para retornar '{1}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">Nenhuma sobrecarga de '{0}' corresponde ao ponteiro de função '{1}'</target>
@@ -922,6 +1007,16 @@
         <target state="translated">O runtime de destino não é compatível com a acessibilidade 'protected', 'protected internal' ou 'private protected' para um membro de uma interface.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">O runtime de destino não dá suporte a convenções de chamada padrão extensíveis ou de ambiente de runtime.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">Não é possível especificar /main quando há uma unidade de compilação com instruções de nível superior.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">Não é possível usar a variável local ou a função local '{0}' declarada em uma instrução de nível superior neste contexto.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">'{0}' foi atribuído com 'UnmanagedCallersOnly' e não pode ser convertido em um tipo delegado. Obtenha um ponteiro de função para esse método.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">retornos de covariante</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">'UnmanagedCallersOnly' só pode ser aplicado a métodos estáticos comuns ou a funções locais estáticas.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">'UnmanagedCallersOnly' só pode ser aplicado a métodos estáticos comuns ou a funções locais estáticas.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">Um membro estático "{0}" não pode ser marcado como override, virtual ou abstract</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">Um membro estático "{0}" não pode ser marcado como override, virtual ou abstract</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ Se tal classe for usada como uma classe base e se a classe derivada definir um d
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">O operador definido pelo usuário não pode obter um objeto do tipo delimitador e se converter em um objeto do tipo delimitador</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">O operador definido pelo usuário não pode obter um objeto do tipo delimitador e se converter em um objeto do tipo delimitador</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ Se tal classe for usada como uma classe base e se a classe derivada definir um d
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">"{0}" não implementa membro de interface "{1}". "{2}" não pode implementar um membro de interface, pois é estático.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">"{0}" não implementa membro de interface "{1}". "{2}" não pode implementar um membro de interface, pois é estático.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ Você pode suprimir o aviso se tiver certeza de que não vai querer aguardar a c
         <target state="translated">O melhor método Adicionar sobrecarregado "{0}" para o elemento do inicializador de coleção está obsoleto. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Instruções yield podem não aparecer no nível superior no código interativo.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">Atributo de segurança "{0}" não é válido neste tipo de declaração. Atributos de segurança são somente válidos em declarações de assembly, tipo e método.</target>
@@ -10727,11 +10857,6 @@ Para incorporar informações de tipo de interoperabilidade para os dois assembl
         <target state="translated">Para o tipo '{0}' a ser usado como um AsyncMethodBuilder para o tipo '{1}', sua propriedade Task deve retornar o tipo '{1}' em vez do tipo '{2}'.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">Os atributos não são permitidos em parâmetros de função local ou parâmetros de tipo</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">O módulo '{0}' no assembly '{1}' está encaminhando o tipo '{2}' para vários assemblies: '{3}' e '{4}'.</target>
@@ -10983,8 +11108,8 @@ Para incorporar informações de tipo de interoperabilidade para os dois assembl
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">As interfaces não podem conter operadores de conversão, igualdade ou desigualdade</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">As interfaces não podem conter operadores de conversão, igualdade ou desigualdade</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ Para incorporar informações de tipo de interoperabilidade para os dois assembl
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">'{0}' não implementa o membro de interface '{1}'. '{2}' não pode implementar implicitamente um membro não público.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index eac1047b697b1..8bcd4e235a351 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -22,6 +22,11 @@
         <target state="translated">Не удается создать сконструированный универсальный тип из неуниверсального типа.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">"{0}": абстрактное событие не может использовать синтаксис метода доступа к событиям.</target>
@@ -102,6 +107,36 @@
         <target state="translated">Асинхронный оператор foreach не работает с переменными типа "{0}", так как "{0}" не содержит открытое определение экземпляра или расширения для "{1}" Возможно, вы имели в виду "foreach", а не "await foreach"?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">Не удается использовать коллекцию динамического типа в асинхронном операторе foreach</target>
@@ -167,6 +202,11 @@
         <target state="translated">Ошибка в синтаксисе командной строки: "{0}" не является допустимым значением для параметра "{1}". Значение должно иметь форму "{2}".</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">"{0}" и переопределяемый элемент "{1}" должны соответствовать по методу доступа, вызываемому только во время инициализации.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">В __arglist невозможно передать аргумент с помощью in или out</target>
@@ -222,6 +267,11 @@
         <target state="translated">Элементы с именем "Clone" не могут использоваться в записях.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">"{0}" не реализует элемент интерфейса "{1}". "{2}" не может реализовывать "{1}".</target>
@@ -342,6 +392,11 @@
         <target state="translated">Свойство контракта на равенство записей "{0}" должно иметь метод доступа get.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">Явное применение атрибута "System.Runtime.CompilerServices.NullableAttribute" не допускается.</target>
@@ -367,6 +422,11 @@
         <target state="translated">Дерево выражений не может содержать значение ref struct или ограниченный тип "{0}".</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Дерево выражений не может содержать выражение индекса, отсчитываемого с конца ("^").</target>
@@ -417,6 +477,11 @@
         <target state="translated">Функция "{0}" является экспериментальной и не поддерживается; используйте "/features:{1}" для включения.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">Функция "{0}" недоступна в C# 8.0. Используйте версию языка {1} или более позднюю.</target>
@@ -462,6 +527,11 @@
         <target state="translated">Невозможно вызвать указатель на функцию с именованными аргументами.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">Свойства экземпляра в интерфейсах не могут иметь инициализаторы.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">"{0}" не может реализовать член интерфейса "{1}" в типе "{2}" из-за наличия параметра __arglist</target>
@@ -657,6 +732,16 @@
         <target state="translated">Чтобы возвращать "{1}", метод "{0}" с блоком итератора должен быть асинхронным ("async").</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">Нет перегруженного метода для "{0}", который соответствует указателю на функцию "{1}".</target>
@@ -922,6 +1007,16 @@
         <target state="translated">Целевая среда выполнения не поддерживает специальные возможности "защищенный", "внутренний защищенный" или "частный защищенный" для члена интерфейса.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">Целевая среда выполнения не поддерживает расширяемые или принадлежащие среде выполнения соглашения о вызовах по умолчанию.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">Невозможно указать параметр /main, если существует единица компиляции с инструкциями верхнего уровня.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">Невозможно использовать локальную переменную или локальную функцию "{0}", объявленную в инструкции верхнего уровня в этом контексте.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">"{0}" имеет атрибут "UnmanagedCallersOnly" и не может быть преобразован в тип делегата. Получите указатель на функцию для этого метода.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">ковариантные возвращаемые значения</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">"UnmanagedCallersOnly" может применяться только к обычным статическим методам или к статическим локальным функциям.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">"UnmanagedCallersOnly" может применяться только к обычным статическим методам или к статическим локальным функциям.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">Статический член "{0}" не может быть помечен как override, virtual или abstract.</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">Статический член "{0}" не может быть помечен как override, virtual или abstract.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">Определенный пользователем оператор не может получить объект данного включающего типа и выполнить преобразование в объект данного включающего типа.</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">Определенный пользователем оператор не может получить объект данного включающего типа и выполнить преобразование в объект данного включающего типа.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">"{0}" не реализует член интерфейса "{1}". '{2}" не может реализовать член интерфейса, потому что он является статическим.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">"{0}" не реализует член интерфейса "{1}". '{2}" не может реализовать член интерфейса, потому что он является статическим.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ You should consider suppressing the warning only if you're sure that you don't w
         <target state="translated">Наиболее подходящий перегруженный метод Add "{0}" для элемента инициализатора набора устарел. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Операторы yield не могут использоваться на верхнем уровне интерактивного кода.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">Атрибут безопасности "{0}" не допускается для этого типа объявления. Атрибуты безопасности допустимы только в сборке, типе и объявлениях метода.</target>
@@ -10727,11 +10857,6 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <target state="translated">Чтобы тип "{0}" можно было использовать как AsyncMethodBuilder для типа "{1}", его свойство Task должно возвращать тип "{1}" вместо "{2}".</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">Атрибуты запрещены для параметров локальной функции и параметров типа</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">Модуль "{0}" в сборке "{1}" перенаправляет тип "{2}" в несколько сборок: "{3}" и "{4}".</target>
@@ -10983,8 +11108,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">Интерфейсы не могут содержать операторы преобразования, проверки равенства и неравенства</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">Интерфейсы не могут содержать операторы преобразования, проверки равенства и неравенства</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">"{0}" не реализует член интерфейса "{1}". "{2}" не может неявно реализовать необщедоступный член.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index d62439eeb1649..155aef582ad42 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -22,6 +22,11 @@
         <target state="translated">Oluşturulmuş genel tür, genel olmayan türden oluşturulamaz.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">'{0}': soyut olay, olay erişeni söz dizimini kullanamaz</target>
@@ -102,6 +107,36 @@
         <target state="translated">'{0}', '{1}' için bir genel örnek veya uzantı tanımı içermediğinden zaman uyumsuz foreach deyimi '{0}' türündeki değişkenler üzerinde çalışamaz. 'await foreach' yerine 'foreach' mi kullanmak istediniz?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">Zaman uyumsuz bir foreach içinde dinamik tür koleksiyonu oluşturulamaz</target>
@@ -167,6 +202,11 @@
         <target state="translated">Komut satırı söz dizimi hatası: '{0}', '{1}' seçeneği için geçerli bir değer değil. Değer '{2}' biçiminde olmalıdır.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">'{0}', geçersiz kılınmış '{1}' üyesinin yalnızca init öğesi bakımından eşleşmelidir</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist, 'in' veya 'out' tarafından geçirilen bir bağımsız değişkene sahip olamaz</target>
@@ -222,6 +267,11 @@
         <target state="translated">'Clone' adlı üyelere kayıtlarda izin verilmez.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">'{0}, '{1}' arabirim üyesini uygulamıyor. '{2}', '{1}' üyesini uygulayamaz.</target>
@@ -342,6 +392,11 @@
         <target state="translated">'{0}' kayıt eşitlik anlaşması özelliğinin get erişimcisine sahip olması gerekir.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">Açık 'System.Runtime.CompilerServices.NullableAttribute' uygulamasına izin verilmiyor.</target>
@@ -367,6 +422,11 @@
         <target state="translated">İfade ağacı, ref yapısında veya kısıtlanmış '{0}' türünde değer içeremez.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">İfade ağacı, sondan dizin ('^') ifadesi içeremez.</target>
@@ -417,6 +477,11 @@
         <target state="translated">'{0}' özelliği deneyseldir ve desteklenmez; etkinleştirmek için '/features:{1}' kullanın.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">'{0}' özelliği C# 8.0'da kullanılamaz. Lütfen {1} veya daha yüksek bir dil sürümü kullanın.</target>
@@ -462,6 +527,11 @@
         <target state="translated">İşlev işaretçisi, adlandırılmış bağımsız değişkenler ile çağrılamaz.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">Arabirimlerdeki örnek özelliklerinin başlatıcıları olamaz.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">'{0}' bir __arglist parametresine sahip olduğundan '{2}' türünde '{1}' arabirim üyesini uygulayamıyor.</target>
@@ -657,6 +732,16 @@
         <target state="translated">Yineleyici bloku olan '{0}' yönteminin '{1}' döndürmek için 'zaman uyumsuz' olması gerekir</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">'{0}' için aşırı yüklemelerin hiçbiri '{1}' işlev işaretçisiyle eşleşmiyor</target>
@@ -922,6 +1007,16 @@
         <target state="translated">Hedef çalışma zamanı, bir arabirim üyesi için 'protected', 'protected internal' veya 'private protected' erişilebilirliğini desteklemez.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">Hedef çalışma zamanı, genişletilebilir veya çalışma zamanı ortamı varsayılanı çağırma kurallarını desteklemiyor.</target>
@@ -942,6 +1037,11 @@
         <target state="translated">Üst düzey deyimleri olan bir derleme birimi varsa /main belirtilemez.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">Bu bağlamda, üst düzey bir ifadede bildirilen '{0}' yerel değişkeni veya yerel işlevi kullanılamaz.</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">'{0}', 'UnmanagedCallersOnly' özniteliğine sahip ve temsilci türüne dönüştürülemez. Bu yöntem için bir işlev işaretçisi edinin.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">birlikte değişken dönüşler</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">'UnmanagedCallersOnly', yalnızca normal statik metotlara veya statik yerel işlevlere uygulanabilir.</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">'UnmanagedCallersOnly', yalnızca normal statik metotlara veya statik yerel işlevlere uygulanabilir.</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">'{0}' statik üyesi geçersiz kılınan, sanal veya soyut olarak işaretlenemez</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">'{0}' statik üyesi geçersiz kılınan, sanal veya soyut olarak işaretlenemez</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ Bu sınıf temel sınıf olarak kullanılırsa ve türetilen sınıf bir yıkıc
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">Kullanıcı tanımlı işleç kapsayan türdeki bir nesneyi alamaz ve kapsayan türdeki bir nesneye dönüştüremez</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">Kullanıcı tanımlı işleç kapsayan türdeki bir nesneyi alamaz ve kapsayan türdeki bir nesneye dönüştüremez</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ Bu sınıf temel sınıf olarak kullanılırsa ve türetilen sınıf bir yıkıc
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">'{0}, '{1}' arabirim üyesini uygulamıyor. '{2}' statik olduğundan bir arabirim üyesi uygulayamaz.</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">'{0}, '{1}' arabirim üyesini uygulamıyor. '{2}' statik olduğundan bir arabirim üyesi uygulayamaz.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ Yalnızca asenkron çağrının tamamlanmasını beklemek istemediğinizden ve 
         <target state="translated">Koleksiyon başlatıcı öğesi için en iyi aşırı yüklenen '{0}' Ekle yöntemi artık kullanılmıyor. {1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Yield deyimleri etkileşimli kodun en üst düzeyinde görünmeyebilir.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">'{0}' güvenlik özniteliği bu bildirim türü için geçerli değil. Güvenlik öznitelikleri yalnızca derleme, tür ve yöntem bildirimlerinde geçerlidir.</target>
@@ -10727,11 +10857,6 @@ Uyarıyı kaldırmak için, /reference kullanabilirsiniz (Birlikte Çalışma T
         <target state="translated">'{0}' türünün '{1}' türü için AsyncMethodBuilder olarak kullanılması için, Task özelliğinin '{2}' türü yerine '{1}' türü döndürmesi gerekir.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">Yerel işlev parametrelerinde veya tür parametrelerinde özniteliklere izin verilmez</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">'{1}' bütünleştirilmiş kodundaki '{0}' modülü, '{2}' türünü birden çok bütünleştirilmiş koda iletiyor: '{3}' ve '{4}'.</target>
@@ -10983,8 +11108,8 @@ Uyarıyı kaldırmak için, /reference kullanabilirsiniz (Birlikte Çalışma T
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">Arabirimler dönüştürme, eşitlik veya eşitsizlik işleçleri içeremez</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">Arabirimler dönüştürme, eşitlik veya eşitsizlik işleçleri içeremez</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ Uyarıyı kaldırmak için, /reference kullanabilirsiniz (Birlikte Çalışma T
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">'{0}, '{1}' arabirim üyesini uygulamıyor. '{2}' genel olmayan bir üyeyi örtük olarak uygulayamaz.</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index 8676c09410b22..a2175804b5f29 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -22,6 +22,11 @@
         <target state="translated">无法从非泛型类型创建构造泛型类型。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">“{0}”: 抽象事件不可使用事件访问器语法</target>
@@ -102,6 +107,36 @@
         <target state="translated">“{0}”不包含“{1}”的公共实例或扩展定义，因此异步 foreach 语句不能作用于“{0}”类型的变量。是否希望使用 "foreach" 而非 "await foreach"?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">无法在异步 foreach 中使用动态类型集合</target>
@@ -167,6 +202,11 @@
         <target state="translated">命令行语法错误:“{0}”不是“{1}”选项的有效值。值的格式必须为 "{2}"。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">“{0}”必须与重写成员“{1}”的“仅 init”匹配</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist 不能有 "in" 或 "out" 传递的参数</target>
@@ -222,6 +267,11 @@
         <target state="translated">记录中不允许使用名为 "Clone" 的成员。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">“{0}”不实现接口成员“{1}”。“{2}”无法实现“{1}”。</target>
@@ -342,6 +392,11 @@
         <target state="translated">记录等同性合同属性“{0}”必须具有 get 访问器。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">不允许显示应用 “System.Runtime.CompilerServices.NullableAttribute”。</target>
@@ -367,6 +422,11 @@
         <target state="translated">表达式树不能包含 ref 结构或受限类型“{0}”的值。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">表达式树不能包含 from-end 索引("^")表达式。</target>
@@ -417,6 +477,11 @@
         <target state="translated">功能“{0}”是实验性的且不受支持；请使用“/features:{1}”来启用。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">功能“{0}”在 C# 8.0 中不可用。请使用语言版本 {1} 或更高版本。</target>
@@ -462,6 +527,11 @@
         <target state="translated">不能使用命名参数调用函数指针。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">接口中的实例属性不能具有初始值设定项。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">“{0}”无法在类型“{2}”中实现接口成员“{1}”，因为它具有 __arglist 参数</target>
@@ -657,6 +732,16 @@
         <target state="translated">具有迭代器块的方法“{0}”必须是“异步的”，这样才能返回“{1}”</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">“{0}”没有与函数指针“{1}”匹配的重载</target>
@@ -922,6 +1007,16 @@
         <target state="translated">目标运行时不支持对接口的成员使用 "protected"、"protected internal" 或 "private protected" 辅助功能。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">目标运行时不支持可扩展或运行时环境默认调用约定。</target>
@@ -942,6 +1037,11 @@
         <target state="translated">如果存在包含顶级语句的编译单元，则不能指定 /main。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">在此上下文中，无法使用在顶级语句中声明的局部变量或本地函数“{0}”。</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">“{0}”使用 "UnmanagedCallersOnly" 进行特性化，无法转换为委托类型。请获取指向此方法的函数指针。</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">协变返回</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">"UnmanagedCallersOnly" 仅可应用于普通静态方法或静态本地函数。</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">"UnmanagedCallersOnly" 仅可应用于普通静态方法或静态本地函数。</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3632,8 +3767,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">静态成员“{0}”不能标记为 override、virtual 或 abstract</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">静态成员“{0}”不能标记为 override、virtual 或 abstract</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5176,8 +5311,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">用户定义的运算符不能采用封闭类型的对象，也不能转换成封闭类型的对象</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">用户定义的运算符不能采用封闭类型的对象，也不能转换成封闭类型的对象</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5946,8 +6081,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">“{0}”不实现接口成员“{1}”。“{2}”无法实现接口成员，因为它是静态的。</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">“{0}”不实现接口成员“{1}”。“{2}”无法实现接口成员，因为它是静态的。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9199,11 +9334,6 @@ You should consider suppressing the warning only if you're sure that you don't w
         <target state="translated">与集合初始值设定项元素最匹配的重载 Add 方法“{0}”已过时。{1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Yield 语句不能出现在交互代码中的顶层。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">安全特性“{0}”对此声明类型无效。安全特性仅对程序集、类型和方法声明有效。</target>
@@ -10732,11 +10862,6 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <target state="translated">对于用作类型“{1}”的 AsyncMethodBuilder 的类型“{0}”，它的任务属性应返回类型“{1}”，而不是类型“{2}”。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">属性在本地函数参数或类型参数中不被允许</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">程序集“{1}”中的模块“{0}”将类型“{2}”转发到多个程序集: “{3}”和“{4}”。</target>
@@ -10988,8 +11113,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">接口不能包含转换、相等或不相等运算符</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">接口不能包含转换、相等或不相等运算符</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -11003,8 +11128,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">“{0}”不实现接口成员“{1}”。“{2}”无法无法隐式实现非公共成员。</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index b098473cdfbfc..ce801c5abd072 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -22,6 +22,11 @@
         <target state="translated">無法從另一個非泛型型別建立建構的泛型型別。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_AbstractConversionNotInvolvingContainedType">
+        <source>User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</source>
+        <target state="new">User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_AbstractEventHasAccessors">
         <source>'{0}': abstract event cannot use event accessor syntax</source>
         <target state="translated">'{0}' 抽象事件無法使用事件存取子語法</target>
@@ -102,6 +107,36 @@
         <target state="translated">因為 '{0}' 不包含 '{1}' 的公用執行個體或延伸模組定義，所以非同步的 foreach 陳述式無法在型別 '{0}' 的變數上運作。您指的是 'foreach' 而不是 'await foreach' 嗎?</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BadAbstractBinaryOperatorSignature">
+        <source>One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecRetType">
+        <source>The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</source>
+        <target state="new">The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractIncDecSignature">
+        <source>The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractShiftOperatorSignature">
+        <source>The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</source>
+        <target state="new">The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractStaticMemberAccess">
+        <source>A static abstract interface member can be accessed only on a type parameter.</source>
+        <target state="new">A static abstract interface member can be accessed only on a type parameter.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_BadAbstractUnaryOperatorSignature">
+        <source>The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</source>
+        <target state="new">The parameter of a unary operator must be the containing type, or its type parameter constrained to it.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_BadDynamicAwaitForEach">
         <source>Cannot use a collection of dynamic type in an asynchronous foreach</source>
         <target state="translated">無法在非同步 foreach 中使用動態類型的集合</target>
@@ -167,6 +202,11 @@
         <target state="translated">命令列語法錯誤: '{0}' 對 '{1}' 選項而言不是有效的值。此值的格式必須是 '{2}'。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_BuilderAttributeDisallowed">
+        <source>The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</source>
+        <target state="new">The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CannotClone">
         <source>The receiver type '{0}' is not a valid record type and is not a struct type.</source>
         <target state="new">The receiver type '{0}' is not a valid record type and is not a struct type.</target>
@@ -212,6 +252,11 @@
         <target state="translated">'{0}' 必須符合被覆寫之成員 '{1}' 的僅供初始化</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CantConvAnonMethReturnType">
+        <source>Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</source>
+        <target state="new">Cannot convert {0} to type '{1}' because the return type does not match the delegate return type</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CantUseInOrOutInArglist">
         <source>__arglist cannot have an argument passed by 'in' or 'out'</source>
         <target state="translated">__arglist 不得包含 'in' 或 'out' 傳遞的引數</target>
@@ -222,6 +267,11 @@
         <target state="translated">記錄中不允許名為 'Clone' 的成員。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotStatic">
+        <source>'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</source>
+        <target state="new">'{0}' does not implement static interface member '{1}'. '{2}' cannot implement the interface member because it is not static.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly">
         <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.</source>
         <target state="translated">'{0}' 未實作介面成員 '{1}'。'{2}' 無法實作 '{1}'。</target>
@@ -342,6 +392,11 @@
         <target state="translated">記錄相等 contract 屬性 '{0}' 必須要有 get 存取子。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExplicitImplementationOfOperatorsMustBeStatic">
+        <source>Explicit implementation of a user-defined operator '{0}' must be declared static</source>
+        <target state="new">Explicit implementation of a user-defined operator '{0}' must be declared static</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExplicitNullableAttribute">
         <source>Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed.</source>
         <target state="translated">不允許明確應用 'System.Runtime.CompilerServices.NullableAttribute'。</target>
@@ -367,6 +422,11 @@
         <target state="translated">運算式樹狀架構不可包含 ref 結構或限制型別 '{0}' 的值。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsAbstractStaticMemberAccess">
+        <source>An expression tree may not contain an access of static abstract interface member</source>
+        <target state="new">An expression tree may not contain an access of static abstract interface member</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">運算式樹狀架構不可包含 from-end index ('^') 運算式。</target>
@@ -417,6 +477,11 @@
         <target state="translated">功能 '{0}' 仍在實驗階段且不具支援；請使用 '/features:{1}' 來啟用。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_FeatureNotAvailableInVersion10">
+        <source>Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</source>
+        <target state="new">Feature '{0}' is not available in C# 10.0. Please use language version {1} or greater.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_FeatureNotAvailableInVersion8">
         <source>Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater.</source>
         <target state="translated">C# 8.0 中無法使用功能 '{0}'。請使用 {1} 或更新的語言版本。</target>
@@ -462,6 +527,11 @@
         <target state="translated">無法以具名引數呼叫函式指標。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers">
+        <source>The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</source>
+        <target state="new">The interface '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The constraint interface '{1}' or its base interface has static abstract members.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_GlobalUsingInNamespace">
         <source>A global using directive cannot be used in a namespace declaration.</source>
         <target state="new">A global using directive cannot be used in a namespace declaration.</target>
@@ -537,6 +607,11 @@
         <target state="translated">介面中的執行個體屬性不可有初始設定式。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod">
+        <source>'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</source>
+        <target state="new">'UnmanagedCallersOnly' method '{0}' cannot implement interface member '{1}' in type '{2}'</target>
+        <note>UnmanagedCallersOnly is not localizable.</note>
+      </trans-unit>
       <trans-unit id="ERR_InterfaceImplementedImplicitlyByVariadic">
         <source>'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter</source>
         <target state="translated">因為介面成員 '{1}' 包含 __arglist 參數，所以 '{0}' 無法在類型 '{2}' 中實作此介面成員</target>
@@ -657,6 +732,16 @@
         <target state="translated">具有迭代區塊的方法 '{0}' 必須為「非同步」才能傳回 '{1}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
+        <source>The #line directive end position must be greater than or equal to the start position</source>
+        <target state="new">The #line directive end position must be greater than or equal to the start position</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_LineSpanDirectiveInvalidValue">
+        <source>The #line directive value is missing or out of range</source>
+        <target state="new">The #line directive value is missing or out of range</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_MethFuncPtrMismatch">
         <source>No overload for '{0}' matches function pointer '{1}'</source>
         <target state="translated">'{0}' 沒有任何多載符合函式指標 '{1}'</target>
@@ -922,6 +1007,16 @@
         <target state="translated">目標執行階段不支援介面成員的 'protected'、'protected internal' 或 'private protected' 存取權。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces">
+        <source>Target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">Target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember">
+        <source>'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</source>
+        <target state="new">'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support static abstract members in interfaces.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportUnmanagedDefaultCallConv">
         <source>The target runtime doesn't support extensible or runtime-environment default calling conventions.</source>
         <target state="translated">目標執行階段不支援可延伸或執行階段環境的預設呼叫慣例。</target>
@@ -942,6 +1037,11 @@
         <target state="translated">如果有編譯單位包含最上層陳述式，就無法指定 /main。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_SimpleProgramIsEmpty">
+        <source>At least one top-level statement must be non-empty.</source>
+        <target state="new">At least one top-level statement must be non-empty.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SimpleProgramLocalIsReferencedOutsideOfTopLevelStatement">
         <source>Cannot use local variable or local function '{0}' declared in a top-level statement in this context.</source>
         <target state="translated">在此內容中，無法使用最上層陳述式中宣告的區域變數或區域函式 '{0}'。</target>
@@ -1062,6 +1162,26 @@
         <target state="translated">'{0}' 使用 'UnmanagedCallersOnly' 屬性化，因此無法轉換為委派類型。取得此方法的函式指標。</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
+      <trans-unit id="ERR_WrongArityAsyncReturn">
+        <source>A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</source>
+        <target state="new">A generic task-like return type was expected, but the type '{0}' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing">
+        <source>The using directive for '{0}' appeared previously as global using</source>
+        <target state="new">The using directive for '{0}' appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="HDN_DuplicateWithGlobalUsing_Title">
+        <source>The using directive appeared previously as global using</source>
+        <target state="new">The using directive appeared previously as global using</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_AsyncMethodBuilderOverride">
+        <source>async method builder override</source>
+        <target state="new">async method builder override</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">Covariant 傳回</target>
@@ -1102,6 +1222,16 @@
         <target state="new">lambda attributes</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureLambdaReturnType">
+        <source>lambda return type</source>
+        <target state="new">lambda return type</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="IDS_FeatureLineSpanDirective">
+        <source>line span directive</source>
+        <target state="new">line span directive</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeaturePositionalFieldsInRecords">
         <source>positional fields in records</source>
         <target state="new">positional fields in records</target>
@@ -1122,6 +1252,11 @@
         <target state="new">with on anonymous types</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureStaticAbstractMembersInInterfaces">
+        <source>static abstract members in interfaces</source>
+        <target state="new">static abstract members in interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureWithOnStructs">
         <source>with on structs</source>
         <target state="new">with on structs</target>
@@ -1258,8 +1393,8 @@
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedCallersOnlyRequiresStatic">
-        <source>'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.</source>
-        <target state="translated">'UnmanagedCallersOnly' 僅適用於一般靜態方法或靜態區域函式。</target>
+        <source>'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.</source>
+        <target state="needs-review-translation">'UnmanagedCallersOnly' 僅適用於一般靜態方法或靜態區域函式。</target>
         <note>UnmanagedCallersOnly is not localizable.</note>
       </trans-unit>
       <trans-unit id="ERR_UnmanagedConstraintNotSatisfied">
@@ -3627,8 +3762,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_StaticNotVirtual">
-        <source>A static member '{0}' cannot be marked as override, virtual, or abstract</source>
-        <target state="translated">靜態成員 '{0}' 不可標記為 override、virtual 或 abstract</target>
+        <source>A static member cannot be marked as '{0}'</source>
+        <target state="needs-review-translation">靜態成員 '{0}' 不可標記為 override、virtual 或 abstract</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverrideNotNew">
@@ -5171,8 +5306,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_IdentityConversion">
-        <source>User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type</source>
-        <target state="translated">使用者定義的運算子無法攜帶封入類型的物件和轉換為封入類型的物件</target>
+        <source>User-defined operator cannot convert a type to itself</source>
+        <target state="needs-review-translation">使用者定義的運算子無法攜帶封入類型的物件和轉換為封入類型的物件</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ConversionNotInvolvingContainedType">
@@ -5941,8 +6076,8 @@ If such a class is used as a base class and if the deriving class defines a dest
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberStatic">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.</source>
-        <target state="translated">'{0}' 未實作介面成員 '{1}'。'{2}' 無法實作介面成員，因為其為靜態。</target>
+        <source>'{0}' does not implement instance interface member '{1}'. '{2}' cannot implement the interface member because it is static.</source>
+        <target state="needs-review-translation">'{0}' 未實作介面成員 '{1}'。'{2}' 無法實作介面成員，因為其為靜態。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CloseUnimplementedInterfaceMemberNotPublic">
@@ -9194,11 +9329,6 @@ You should consider suppressing the warning only if you're sure that you don't w
         <target state="translated">集合初始設定式元素最符合的多載 Add 方法 '{0}' 已經過時。{1}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_IteratorInInteractive">
-        <source>Yield statements may not appear at the top level in interactive code.</source>
-        <target state="translated">Yield 陳述式不可出現在互動式程式碼的最上層。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_SecurityAttributeInvalidTarget">
         <source>Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.</source>
         <target state="translated">安全屬性 '{0}' 在此宣告類型上無效。安全屬性只有在組件、類型和方法宣告上才有效。</target>
@@ -10727,11 +10857,6 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <target state="translated">若要讓 '{0}' 類型作為 '{1}' 類型的 AsyncMethodBuilder，其 Task 屬性應傳回 '{1}' 類型，而非 '{2}' 類型。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_AttributesInLocalFuncDecl">
-        <source>Attributes are not allowed on local function parameters or type parameters</source>
-        <target state="translated">區域函式參數或型別參數中不允許屬性</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_TypeForwardedToMultipleAssemblies">
         <source>Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.</source>
         <target state="translated">組件 '{1}' 中的模組 '{0}' 正在將類型 '{2}' 轉送給多個組件: '{3}' 及 '{4}'。</target>
@@ -10983,8 +11108,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_InterfacesCantContainConversionOrEqualityOperators">
-        <source>Interfaces cannot contain conversion, equality, or inequality operators</source>
-        <target state="translated">介面不能包含轉換、等式或不等式運算子</target>
+        <source>Conversion, equality, or inequality operators declared in interfaces must be abstract</source>
+        <target state="needs-review-translation">介面不能包含轉換、等式或不等式運算子</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation">
@@ -10998,8 +11123,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
         <note />
       </trans-unit>
       <trans-unit id="ERR_ImplicitImplementationOfNonPublicInterfaceMember">
-        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member.</source>
-        <target state="translated">'{0}' 未實作介面成員 '{1}'。'{2}' 無法隱含地實作非公開成員。</target>
+        <source>'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</source>
+        <target state="new">'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member in C# {3}. Please use language version '{4}' or greater.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MostSpecificImplementationIsNotFound">
diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index 2c59e7cc97d26..bc35ca5830830 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -1609,7 +1609,8 @@ public void LangVersion_NoValueSpecified()
         [InlineData("iso-3")]
         [InlineData("iso1")]
         [InlineData("8.1")]
-        [InlineData("10")]
+        [InlineData("10.1")]
+        [InlineData("11")]
         [InlineData("1000")]
         public void LangVersion_BadVersion(string value)
         {
@@ -1663,7 +1664,9 @@ public void LanguageVersionAdded_Canary()
             // When a new version is added, this test will break. This list must be checked:
             // - update the "UpgradeProject" codefixer
             // - update all the tests that call this canary
-            AssertEx.SetEqual(new[] { "default", "1", "2", "3", "4", "5", "6", "7.0", "7.1", "7.2", "7.3", "8.0", "9.0", "latest", "latestmajor", "preview" },
+            // - update MaxSupportedLangVersion (a relevant test should break when new version is introduced)
+            // - email release management to add to the release notes (see old example: https://github.com/dotnet/core/pull/1454)
+            AssertEx.SetEqual(new[] { "default", "1", "2", "3", "4", "5", "6", "7.0", "7.1", "7.2", "7.3", "8.0", "9.0", "10.0", "latest", "latestmajor", "preview" },
                 Enum.GetValues(typeof(LanguageVersion)).Cast<LanguageVersion>().Select(v => v.ToDisplayString()));
             // For minor versions and new major versions, the format should be "x.y", such as "7.1"
         }
@@ -1695,6 +1698,7 @@ public void LanguageVersion_GetErrorCode()
                 ErrorCode.ERR_FeatureNotAvailableInVersion7_3,
                 ErrorCode.ERR_FeatureNotAvailableInVersion8,
                 ErrorCode.ERR_FeatureNotAvailableInVersion9,
+                ErrorCode.ERR_FeatureNotAvailableInVersion10,
             };
 
             AssertEx.SetEqual(versions, errorCodes);
@@ -1716,9 +1720,10 @@ public void LanguageVersion_GetErrorCode()
             InlineData(LanguageVersion.CSharp7_3, LanguageVersion.CSharp7_3),
             InlineData(LanguageVersion.CSharp8, LanguageVersion.CSharp8),
             InlineData(LanguageVersion.CSharp9, LanguageVersion.CSharp9),
-            InlineData(LanguageVersion.CSharp9, LanguageVersion.LatestMajor),
-            InlineData(LanguageVersion.CSharp9, LanguageVersion.Latest),
-            InlineData(LanguageVersion.CSharp9, LanguageVersion.Default),
+            InlineData(LanguageVersion.CSharp10, LanguageVersion.CSharp10),
+            InlineData(LanguageVersion.CSharp10, LanguageVersion.LatestMajor),
+            InlineData(LanguageVersion.CSharp10, LanguageVersion.Latest),
+            InlineData(LanguageVersion.CSharp10, LanguageVersion.Default),
             InlineData(LanguageVersion.Preview, LanguageVersion.Preview),
             ]
         public void LanguageVersion_MapSpecifiedToEffectiveVersion(LanguageVersion expectedMappedVersion, LanguageVersion input)
@@ -1757,6 +1762,8 @@ public void LanguageVersion_MapSpecifiedToEffectiveVersion(LanguageVersion expec
             InlineData("8.0", true, LanguageVersion.CSharp8),
             InlineData("9", true, LanguageVersion.CSharp9),
             InlineData("9.0", true, LanguageVersion.CSharp9),
+            InlineData("10", true, LanguageVersion.CSharp10),
+            InlineData("10.0", true, LanguageVersion.CSharp10),
             InlineData("08", false, LanguageVersion.Default),
             InlineData("07.1", false, LanguageVersion.Default),
             InlineData("default", true, LanguageVersion.Default),
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Locations.cs b/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Locations.cs
index 18fc9ecd2f117..5ce3b07416ccc 100644
--- a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Locations.cs
+++ b/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Locations.cs
@@ -195,7 +195,7 @@ record struct S
 {
 }
 ";
-            CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
+            CreateCompilation(source, parseOptions: TestOptions.Regular10).VerifyDiagnostics(
                 // (8,2): warning CS0657: 'assembly' is not a valid attribute location for this declaration. Valid attribute locations for this declaration are 'type'. All attributes in this block will be ignored.
                 Diagnostic(ErrorCode.WRN_AttributeLocationOnBadDeclaration, "assembly").WithArguments("assembly", "type"),
                 // (9,2): warning CS0657: 'module' is not a valid attribute location for this declaration. Valid attribute locations for this declaration are 'type'. All attributes in this block will be ignored.
@@ -243,7 +243,7 @@ record class S
 {
 }
 ";
-            CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
+            CreateCompilation(source, parseOptions: TestOptions.Regular10).VerifyDiagnostics(
                 // (8,2): warning CS0657: 'assembly' is not a valid attribute location for this declaration. Valid attribute locations for this declaration are 'type'. All attributes in this block will be ignored.
                 Diagnostic(ErrorCode.WRN_AttributeLocationOnBadDeclaration, "assembly").WithArguments("assembly", "type"),
                 // (9,2): warning CS0657: 'module' is not a valid attribute location for this declaration. Valid attribute locations for this declaration are 'type'. All attributes in this block will be ignored.
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Nullable.cs b/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Nullable.cs
index 7a3bd02a723eb..1bc67f9513729 100644
--- a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Nullable.cs
+++ b/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Nullable.cs
@@ -4321,6 +4321,9 @@ public void ModuleMissingAttribute_OperatorReturnType()
                 // (3,19): error CS0518: Predefined type 'System.Runtime.CompilerServices.NullableAttribute' is not defined or imported
                 //     public static object? operator+(C a, C b) => null;
                 Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "object?").WithArguments("System.Runtime.CompilerServices.NullableAttribute").WithLocation(3, 19),
+                // (3,35): error CS0518: Predefined type 'System.Runtime.CompilerServices.NullableContextAttribute' is not defined or imported
+                //     public static object? operator+(C a, C b) => null;
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "+").WithArguments("System.Runtime.CompilerServices.NullableContextAttribute").WithLocation(3, 35),
                 // (3,37): error CS0518: Predefined type 'System.Runtime.CompilerServices.NullableAttribute' is not defined or imported
                 //     public static object? operator+(C a, C b) => null;
                 Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "C a").WithArguments("System.Runtime.CompilerServices.NullableAttribute").WithLocation(3, 37),
@@ -4343,6 +4346,9 @@ public void ModuleMissingAttribute_OperatorParameters()
                 // (3,19): error CS0518: Predefined type 'System.Runtime.CompilerServices.NullableAttribute' is not defined or imported
                 //     public static object operator+(C a, object?[] b) => a;
                 Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "object").WithArguments("System.Runtime.CompilerServices.NullableAttribute").WithLocation(3, 19),
+                // (3,34): error CS0518: Predefined type 'System.Runtime.CompilerServices.NullableContextAttribute' is not defined or imported
+                //     public static object operator+(C a, object?[] b) => a;
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "+").WithArguments("System.Runtime.CompilerServices.NullableContextAttribute").WithLocation(3, 34),
                 // (3,36): error CS0518: Predefined type 'System.Runtime.CompilerServices.NullableAttribute' is not defined or imported
                 //     public static object operator+(C a, object?[] b) => a;
                 Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "C a").WithArguments("System.Runtime.CompilerServices.NullableAttribute").WithLocation(3, 36),
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.cs b/src/Compilers/CSharp/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.cs
index c0fcfa86bd9b4..507f72f53e62e 100644
--- a/src/Compilers/CSharp/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.cs
@@ -1074,7 +1074,36 @@ internal class CAttribute : System.Attribute { public CAttribute() {} }";
 
             var requestor = CreateCompilation(
     @"
-[assembly: C()] //causes optimistic granting
+[assembly: C()]
+[assembly: System.Reflection.AssemblyKeyName(""roslynTestContainer"")]
+public class A
+{
+}",
+                new[] { new CSharpCompilationReference(other) },
+                assemblyName: "John",
+                options: TestOptions.SigningReleaseDll);
+
+            Assert.True(ByteSequenceComparer.Equals(s_publicKey, requestor.Assembly.Identity.PublicKey));
+            requestor.VerifyDiagnostics();
+        }
+
+        [ConditionalTheory(typeof(WindowsOnly), Reason = ConditionalSkipReason.TestExecutionNeedsWindowsTypes)]
+        [MemberData(nameof(AllProviderParseOptions))]
+        public void IVTDeferredFailSignMismatch_AssemblyKeyName(CSharpParseOptions parseOptions)
+        {
+            string s = @"[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""John, PublicKey=00240000048000009400000006020000002400005253413100040000010001002b986f6b5ea5717d35c72d38561f413e267029efa9b5f107b9331d83df657381325b3a67b75812f63a9436ceccb49494de8f574f8e639d4d26c0fcf8b0e9a1a196b80b6f6ed053628d10d027e032df2ed1d60835e5f47d32c9ef6da10d0366a319573362c821b5f8fa5abc5bb22241de6f666a85d82d6ba8c3090d01636bd2bb"")]
+            internal class AssemblyKeyNameAttribute : System.Attribute { public AssemblyKeyNameAttribute() {} }";
+
+            var other = CreateCompilation(s,
+                assemblyName: "Paul",
+                options: TestOptions.SigningReleaseDll,
+                parseOptions: parseOptions); //not signed. cryptoKeyFile: KeyPairFile,
+
+            other.VerifyDiagnostics();
+
+            var requestor = CreateCompilation(
+    @"
+[assembly: AssemblyKeyName()] //causes optimistic granting
 [assembly: System.Reflection.AssemblyKeyName(""roslynTestContainer"")]
 public class A
 {
@@ -1105,15 +1134,50 @@ internal class CAttribute : System.Attribute { public CAttribute() {} }";
 
             var requestor = CreateCompilation(
     @"
-[assembly: C()]  //causes optimistic granting
+[assembly: C()]
+[assembly: System.Reflection.AssemblyKeyName(""roslynTestContainer"")]
+public class A
+{
+}",
+                new MetadataReference[] { new CSharpCompilationReference(other) },
+                assemblyName: "John",
+                options: TestOptions.SigningReleaseDll,
+                parseOptions: parseOptions);
+
+            Assert.True(ByteSequenceComparer.Equals(s_publicKey, requestor.Assembly.Identity.PublicKey));
+            requestor.VerifyDiagnostics(
+                // (2,12): error CS0122: 'CAttribute' is inaccessible due to its protection level
+                // [assembly: C()]
+                Diagnostic(ErrorCode.ERR_BadAccess, "C").WithArguments("CAttribute").WithLocation(2, 12)
+                );
+        }
+
+        [ConditionalTheory(typeof(WindowsOnly), Reason = ConditionalSkipReason.TestExecutionNeedsWindowsTypes)]
+        [MemberData(nameof(AllProviderParseOptions))]
+        public void IVTDeferredFailKeyMismatch_AssemblyKeyName(CSharpParseOptions parseOptions)
+        {
+            //key is wrong in the first digit. correct key starts with 0
+            string s = @"[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""John, PublicKey=10240000048000009400000006020000002400005253413100040000010001002b986f6b5ea5717d35c72d38561f413e267029efa9b5f107b9331d83df657381325b3a67b75812f63a9436ceccb49494de8f574f8e639d4d26c0fcf8b0e9a1a196b80b6f6ed053628d10d027e032df2ed1d60835e5f47d32c9ef6da10d0366a319573362c821b5f8fa5abc5bb22241de6f666a85d82d6ba8c3090d01636bd2bb"")]
+            internal class AssemblyKeyNameAttribute : System.Attribute { public AssemblyKeyNameAttribute() {} }";
+
+            var other = CreateCompilation(s,
+                options: TestOptions.SigningReleaseDll.WithCryptoKeyFile(s_keyPairFile),
+                assemblyName: "Paul",
+                parseOptions: parseOptions);
+
+            other.VerifyDiagnostics();
+
+            var requestor = CreateCompilation(
+    @"
+[assembly: AssemblyKeyName()]
 [assembly: System.Reflection.AssemblyKeyName(""roslynTestContainer"")]
 public class A
 {
 }",
-            new MetadataReference[] { new CSharpCompilationReference(other) },
-            assemblyName: "John",
-             options: TestOptions.SigningReleaseDll,
-             parseOptions: parseOptions);
+                new MetadataReference[] { new CSharpCompilationReference(other) },
+                assemblyName: "John",
+                options: TestOptions.SigningReleaseDll,
+                parseOptions: parseOptions);
 
             Assert.True(ByteSequenceComparer.Equals(s_publicKey, requestor.Assembly.Identity.PublicKey));
             requestor.VerifyDiagnostics(
@@ -1121,8 +1185,11 @@ public class A
                 // but the public key of the output assembly ('John, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2')
                 // does not match that specified by the InternalsVisibleTo attribute in the granting assembly.
                 Diagnostic(ErrorCode.ERR_FriendRefNotEqualToThis)
-                .WithArguments("Paul, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2", "John, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2")
-                .WithLocation(1, 1)
+                    .WithArguments("Paul, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2", "John, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2")
+                    .WithLocation(1, 1),
+                // (2,12): error CS0122: 'AssemblyKeyNameAttribute' is inaccessible due to its protection level
+                // [assembly: AssemblyKeyName()]
+                Diagnostic(ErrorCode.ERR_BadAccess, "AssemblyKeyName").WithArguments("AssemblyKeyNameAttribute").WithLocation(2, 12)
                 );
         }
 
@@ -1174,7 +1241,43 @@ internal class CAttribute : System.Attribute { public CAttribute() {} }";
             var requestor = CreateCompilation(
     @"
 
-[assembly: C()]  //causes optimistic granting
+[assembly: C()]
+[assembly: System.Reflection.AssemblyKeyName(""roslynTestContainer"")]
+public class A
+{
+}",
+                new MetadataReference[] { new CSharpCompilationReference(other) },
+                TestOptions.SigningReleaseDll,
+                assemblyName: "John",
+                parseOptions: parseOptions);
+
+            Assert.False(other.Assembly.GivesAccessTo(requestor.Assembly));
+            requestor.VerifyDiagnostics(
+                // (3,12): error CS0122: 'CAttribute' is inaccessible due to its protection level
+                // [assembly: C()]
+                Diagnostic(ErrorCode.ERR_BadAccess, "C").WithArguments("CAttribute").WithLocation(3, 12)
+                );
+        }
+
+        [ConditionalTheory(typeof(WindowsOnly), Reason = ConditionalSkipReason.TestExecutionNeedsWindowsTypes)]
+        [MemberData(nameof(AllProviderParseOptions))]
+        public void IVTDeferredFailKeyMismatchIAssembly_AssemblyKeyName(CSharpParseOptions parseOptions)
+        {
+            //key is wrong in the first digit. correct key starts with 0
+            string s = @"[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""John, PublicKey=10240000048000009400000006020000002400005253413100040000010001002b986f6b5ea5717d35c72d38561f413e267029efa9b5f107b9331d83df657381325b3a67b75812f63a9436ceccb49494de8f574f8e639d4d26c0fcf8b0e9a1a196b80b6f6ed053628d10d027e032df2ed1d60835e5f47d32c9ef6da10d0366a319573362c821b5f8fa5abc5bb22241de6f666a85d82d6ba8c3090d01636bd2bb"")]
+            internal class AssemblyKeyNameAttribute : System.Attribute { public AssemblyKeyNameAttribute() {} }";
+
+            var other = CreateCompilation(s,
+                options: TestOptions.SigningReleaseDll.WithCryptoKeyFile(s_keyPairFile),
+                assemblyName: "Paul",
+                parseOptions: parseOptions);
+
+            other.VerifyDiagnostics();
+
+            var requestor = CreateCompilation(
+    @"
+
+[assembly: AssemblyKeyName()]
 [assembly: System.Reflection.AssemblyKeyName(""roslynTestContainer"")]
 public class A
 {
@@ -1190,8 +1293,11 @@ public class A
                 // but the public key of the output assembly ('John, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2')
                 // does not match that specified by the InternalsVisibleTo attribute in the granting assembly.
                 Diagnostic(ErrorCode.ERR_FriendRefNotEqualToThis)
-                .WithArguments("Paul, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2", "John, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2")
-                .WithLocation(1, 1)
+                    .WithArguments("Paul, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2", "John, Version=0.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2")
+                    .WithLocation(1, 1),
+                // (3,12): error CS0122: 'AssemblyKeyNameAttribute' is inaccessible due to its protection level
+                // [assembly: AssemblyKeyName()]
+                Diagnostic(ErrorCode.ERR_BadAccess, "AssemblyKeyName").WithArguments("AssemblyKeyNameAttribute").WithLocation(3, 12)
                 );
         }
 
@@ -1671,6 +1777,30 @@ static void Goo() {}
             assembly.VerifyDiagnostics(Diagnostic(ErrorCode.ERR_SignButNoPrivateKey).WithArguments(s_publicKeyFile));
         }
 
+        [Theory]
+        [MemberData(nameof(AllProviderParseOptions))]
+        public void AssemblySignatureKeyOnNetModule(CSharpParseOptions parseOptions)
+        {
+            var other = CreateCompilation(@"
+[assembly: System.Reflection.AssemblySignatureKeyAttribute(
+    ""00240000048000009400000006020000002400005253413100040000010001002b986f6b5ea5717d35c72d38561f413e267029efa9b5f107b9331d83df657381325b3a67b75812f63a9436ceccb49494de8f574f8e639d4d26c0fcf8b0e9a1a196b80b6f6ed053628d10d027e032df2ed1d60835e5f47d32c9ef6da10d0366a319573362c821b5f8fa5abc5bb22241de6f666a85d82d6ba8c3090d01636bd2bb"",
+    ""bc6402e37ad723580b576953f40475ceae4b784d3661b90c3c6f5a1f7283388a7880683e0821610bee977f70506bb75584080e01b2ec97483c4d601ce1c981752a07276b420d78594d0ef28f8ec016d0a5b6d56cfc22e9f25a2ed9545942ccbf2d6295b9528641d98776e06a3273ab233271a3c9f53099b4d4e029582a6d5819"")]
+
+public class C
+{
+    static void Goo() {}
+}",
+                options: TestOptions.SigningReleaseModule, parseOptions: parseOptions);
+
+            var comp = CreateCompilation("",
+                references: new[] { other.EmitToImageReference() },
+                options: TestOptions.SigningReleaseDll,
+                parseOptions: parseOptions);
+
+            comp.VerifyDiagnostics();
+            Assert.StartsWith("0024000004", ((SourceAssemblySymbol)comp.Assembly.Modules[1].ContainingAssembly).SignatureKey);
+        }
+
         [Theory]
         [MemberData(nameof(AllProviderParseOptions))]
         public void DelaySignItWithOnlyPublicKey(CSharpParseOptions parseOptions)
@@ -2696,5 +2826,73 @@ static void Goo() {}
             Assert.True(IsFileFullSigned(tempFile));
         }
         #endregion
+
+        [Theory]
+        [MemberData(nameof(AllProviderParseOptions))]
+        [WorkItem(1341051, "https://dev.azure.com/devdiv/DevDiv/_workitems/edit/1341051")]
+        public void IVT_Circularity(CSharpParseOptions parseOptions)
+        {
+            string lib_cs = @"
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""WantsIVTAccess"")]
+
+public abstract class TestBaseClass
+{
+    protected internal virtual bool SupportSvgImages { get; }
+}
+";
+            var libRef = CreateCompilation(lib_cs, options: TestOptions.SigningReleaseDll, parseOptions: parseOptions).EmitToImageReference();
+
+            string source1 = @"
+[assembly: Class1]
+";
+
+            string source2 = @"
+public class Class1 : TestBaseClass
+{
+    protected internal override bool SupportSvgImages { get { return true; } }
+}
+";
+            // To find what the property overrides, an IVT check is involved so we need to bind assembly-level attributes
+            var c2 = CreateCompilation(new[] { source1, source2 }, new[] { libRef }, assemblyName: "WantsIVTAccess",
+                options: TestOptions.SigningReleaseDll, parseOptions: parseOptions);
+            c2.VerifyEmitDiagnostics(
+                // (2,12): error CS0616: 'Class1' is not an attribute class
+                // [assembly: Class1]
+                Diagnostic(ErrorCode.ERR_NotAnAttributeClass, "Class1").WithArguments("Class1").WithLocation(2, 12)
+                );
+        }
+
+        [Fact, WorkItem(1341051, "https://dev.azure.com/devdiv/DevDiv/_workitems/edit/1341051")]
+        public void IVT_Circularity_AttributeReferencesProperty()
+        {
+            string lib_cs = @"
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""WantsIVTAccess"")]
+
+public abstract class TestBaseClass
+{
+    protected internal virtual bool SupportSvgImages { get; }
+}
+public class MyAttribute : System.Attribute
+{
+    public MyAttribute(string s) { }
+}
+";
+            var libRef = CreateCompilation(lib_cs, options: TestOptions.SigningReleaseDll).EmitToImageReference();
+
+            string source1 = @"
+[assembly: MyAttribute(Class1.Constant)]
+";
+
+            string source2 = @"
+public class Class1 : TestBaseClass
+{
+    internal const string Constant = ""text"";
+    protected internal override bool SupportSvgImages { get { return true; } }
+}
+";
+            // To find what the property overrides, an IVT check is involved so we need to bind assembly-level attributes
+            var c2 = CreateCompilation(new[] { source1, source2 }, new[] { libRef }, assemblyName: "WantsIVTAccess", options: TestOptions.SigningReleaseDll);
+            c2.VerifyEmitDiagnostics();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMethodBuilderOverrideTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMethodBuilderOverrideTests.cs
new file mode 100644
index 0000000000000..e76fddcd11a38
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMethodBuilderOverrideTests.cs
@@ -0,0 +1,2140 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
+{
+    public class CodeGenAsyncMethodBuilderOverrideTests : EmitMetadataTestBase
+    {
+        private const string AsyncMethodBuilderAttribute =
+            "namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute : System.Attribute { public AsyncMethodBuilderAttribute(System.Type t) { } } } ";
+
+        private static string AsyncBuilderCode(string builderTypeName, string tasklikeTypeName, string? genericTypeParameter = null, bool isStruct = false)
+        {
+            string ofT = genericTypeParameter == null ? "" : "<" + genericTypeParameter + ">";
+
+            return $@"
+public {(isStruct ? "struct" : "class")} {builderTypeName}{ofT}
+{{
+    public static {builderTypeName}{ofT} Create() => new {builderTypeName}{ofT}(new {tasklikeTypeName}{ofT}());
+    private {tasklikeTypeName}{ofT} _task;
+    private {builderTypeName}({tasklikeTypeName}{ofT} task) {{ _task = task; }}
+    public void SetStateMachine(IAsyncStateMachine stateMachine) {{ }}
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine {{ stateMachine.MoveNext(); }}
+    public void SetException(System.Exception e) {{ }}
+    public void SetResult({(genericTypeParameter == null ? "" : genericTypeParameter + " result")}) {{ {(genericTypeParameter == null ? "" : "_task._result = result;")} }}
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public {tasklikeTypeName}{ofT} Task => _task;
+}}
+";
+        }
+
+        private static string AwaitableTypeCode(string taskLikeName, string? genericTypeParameter = null, bool isStruct = false)
+        {
+            if (genericTypeParameter == null)
+            {
+                return $@"
+public {(isStruct ? "struct" : "class")} {taskLikeName}
+{{
+    internal Awaiter GetAwaiter() => new Awaiter();
+    internal class Awaiter : INotifyCompletion
+    {{
+        public void OnCompleted(Action a) {{ }}
+        internal bool IsCompleted => true;
+        internal void GetResult() {{ }}
+    }}
+}}";
+            }
+            else
+            {
+                string ofT = "<" + genericTypeParameter + ">";
+                return $@"
+public {(isStruct ? "struct" : "class")} {taskLikeName}{ofT}
+{{
+    internal {genericTypeParameter} _result;
+    public {genericTypeParameter} Result => _result;
+    internal Awaiter GetAwaiter() => new Awaiter(this);
+    internal class Awaiter : INotifyCompletion
+    {{
+        private readonly {taskLikeName}{ofT} _task;
+        internal Awaiter({taskLikeName}{ofT} task) {{ _task = task; }}
+        public void OnCompleted(Action a) {{ }}
+        internal bool IsCompleted => true;
+        internal {genericTypeParameter} GetResult() => _task.Result;
+    }}
+}}
+";
+            }
+        }
+
+        [Theory]
+        [InlineData("[AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]")]
+        [InlineData("[AsyncMethodBuilder(typeof(object))]")]
+        [InlineData("[AsyncMethodBuilder(null)]")]
+        [InlineData("")]
+        public void BuilderOnMethod_DummyBuilderOnType(string dummyBuilder)
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Console.WriteLine(await C.M());
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    public static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{dummyBuilder}
+{AwaitableTypeCode("MyTask")}
+
+{dummyBuilder}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.Regular9);
+            compilation.VerifyDiagnostics(
+                // (11,25): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "F").WithArguments("async method builder override", "10.0").WithLocation(11, 25),
+                // (14,28): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "G").WithArguments("async method builder override", "10.0").WithLocation(14, 28),
+                // (17,37): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //     public static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "M").WithArguments("async method builder override", "10.0").WithLocation(17, 37)
+                );
+
+            compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.Regular10);
+            var verifier = CompileAndVerify(compilation, expectedOutput: "M F G 3");
+            verifier.VerifyDiagnostics();
+            var testData = verifier.TestData;
+            var method = (MethodSymbol)testData.GetMethodData("C.F()").Method;
+            Assert.True(method.IsAsync);
+            Assert.True(method.IsAsyncEffectivelyReturningTask(compilation));
+            method = (MethodSymbol)testData.GetMethodData("C.G<T>(T)").Method;
+            Assert.True(method.IsAsync);
+            Assert.True(method.IsAsyncEffectivelyReturningGenericTask(compilation));
+            verifier.VerifyIL("C.F()", @"
+{
+  // Code size       45 (0x2d)
+  .maxstack  2
+  .locals init (C.<F>d__0 V_0)
+  IL_0000:  ldloca.s   V_0
+  IL_0002:  call       ""MyTaskMethodBuilder MyTaskMethodBuilder.Create()""
+  IL_0007:  stfld      ""MyTaskMethodBuilder C.<F>d__0.<>t__builder""
+  IL_000c:  ldloca.s   V_0
+  IL_000e:  ldc.i4.m1
+  IL_000f:  stfld      ""int C.<F>d__0.<>1__state""
+  IL_0014:  ldloc.0
+  IL_0015:  ldfld      ""MyTaskMethodBuilder C.<F>d__0.<>t__builder""
+  IL_001a:  ldloca.s   V_0
+  IL_001c:  callvirt   ""void MyTaskMethodBuilder.Start<C.<F>d__0>(ref C.<F>d__0)""
+  IL_0021:  ldloc.0
+  IL_0022:  ldfld      ""MyTaskMethodBuilder C.<F>d__0.<>t__builder""
+  IL_0027:  callvirt   ""MyTask MyTaskMethodBuilder.Task.get""
+  IL_002c:  ret
+}
+");
+            verifier.VerifyIL("C.G<T>(T)", @"
+{
+  // Code size       53 (0x35)
+  .maxstack  2
+  .locals init (C.<G>d__1<T> V_0)
+  IL_0000:  ldloca.s   V_0
+  IL_0002:  call       ""MyTaskMethodBuilder<T> MyTaskMethodBuilder<T>.Create()""
+  IL_0007:  stfld      ""MyTaskMethodBuilder<T> C.<G>d__1<T>.<>t__builder""
+  IL_000c:  ldloca.s   V_0
+  IL_000e:  ldarg.0
+  IL_000f:  stfld      ""T C.<G>d__1<T>.t""
+  IL_0014:  ldloca.s   V_0
+  IL_0016:  ldc.i4.m1
+  IL_0017:  stfld      ""int C.<G>d__1<T>.<>1__state""
+  IL_001c:  ldloc.0
+  IL_001d:  ldfld      ""MyTaskMethodBuilder<T> C.<G>d__1<T>.<>t__builder""
+  IL_0022:  ldloca.s   V_0
+  IL_0024:  callvirt   ""void MyTaskMethodBuilder<T>.Start<C.<G>d__1<T>>(ref C.<G>d__1<T>)""
+  IL_0029:  ldloc.0
+  IL_002a:  ldfld      ""MyTaskMethodBuilder<T> C.<G>d__1<T>.<>t__builder""
+  IL_002f:  callvirt   ""MyTask<T> MyTaskMethodBuilder<T>.Task.get""
+  IL_0034:  ret
+}
+");
+        }
+
+        [Fact]
+        public void BuilderOnMethod_Nullability()
+        {
+            var source = $@"
+#nullable enable
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t)
+    {{
+        await Task.Delay(0);
+        return default(T); // 1
+    }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    public static async MyTask<string> M()
+    {{
+        return await G((string?)null); // 2
+    }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    public static async MyTask<string?> M2() {{ return await G((string?)null); }}
+}}
+
+// no attribute
+{AwaitableTypeCode("MyTask")}
+
+// no attribute
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.Regular10);
+            compilation.VerifyDiagnostics(
+                // (14,16): warning CS8603: Possible null reference return.
+                //         return default(T); // 1
+                Diagnostic(ErrorCode.WRN_NullReferenceReturn, "default(T)").WithLocation(14, 16),
+                // (20,16): warning CS8603: Possible null reference return.
+                //         return await G((string?)null); // 2
+                Diagnostic(ErrorCode.WRN_NullReferenceReturn, "await G((string?)null)").WithLocation(20, 16),
+                // (44,16): warning CS8618: Non-nullable field '_result' must contain a non-null value when exiting constructor. Consider declaring the field as nullable.
+                //     internal T _result;
+                Diagnostic(ErrorCode.WRN_UninitializedNonNullableField, "_result").WithArguments("field", "_result").WithLocation(44, 16)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_BadReturns()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ await Task.Yield(); return 1; }} // 1
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ await Task.Yield(); return; }} // 2
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ await Task.Yield(); return null; }} // 3
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M2(MyTask<int> mt) {{ await Task.Yield(); return mt; }} // 4
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask M2(bool b) => b ? await Task.Yield() : await Task.Yield(); // 5
+}}
+
+// no attribute
+{AwaitableTypeCode("MyTask")}
+
+// no attribute
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (9,51): error CS1997: Since 'C.F()' is an async method that returns 'Task', a return keyword must not be followed by an object expression. Did you intend to return 'Task<T>'?
+                //     static async MyTask F() { await Task.Yield(); return 1; } // 1
+                Diagnostic(ErrorCode.ERR_TaskRetNoObjectRequired, "return").WithArguments("C.F()").WithLocation(9, 51),
+                // (12,60): error CS0126: An object of a type convertible to 'T' is required
+                //     static async MyTask<T> G<T>(T t) { await Task.Yield(); return; } // 2
+                Diagnostic(ErrorCode.ERR_RetObjectRequired, "return").WithArguments("T").WithLocation(12, 60),
+                // (15,63): error CS0037: Cannot convert null to 'int' because it is a non-nullable value type
+                //     static async MyTask<int> M() { await Task.Yield(); return null; } // 3
+                Diagnostic(ErrorCode.ERR_ValueCantBeNull, "null").WithArguments("int").WithLocation(15, 63),
+                // (18,78): error CS4016: Since this is an async method, the return expression must be of type 'int' rather than 'Task<int>'
+                //     static async MyTask<int> M2(MyTask<int> mt) { await Task.Yield(); return mt; } // 4
+                Diagnostic(ErrorCode.ERR_BadAsyncReturnExpression, "mt").WithArguments("int").WithLocation(18, 78),
+                // (21,39): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
+                //     static async MyTask M2(bool b) => b ? await Task.Yield() : await Task.Yield(); // 5
+                Diagnostic(ErrorCode.ERR_IllegalStatement, "b ? await Task.Yield() : await Task.Yield()").WithLocation(21, 39)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_IgnoreBadBuilderOnType()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Console.WriteLine(await C.M());
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    public static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+[AsyncMethodBuilder(typeof(void))] // void
+{AwaitableTypeCode("MyTask")}
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder))] // wrong arity
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTask")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics();
+        }
+
+        [Fact]
+        public void BuilderOnMethod_IgnoreBadBuilderOnType_CreateReturnsInt()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+}}
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder))]
+{AwaitableTypeCode("MyTask")}
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder<>))]
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTask")
+    .Replace("public static IgnoredTaskMethodBuilder Create() => new IgnoredTaskMethodBuilder(new MyTask());", "public static int Create() => 0;")}
+
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTask", "T")
+    .Replace("public static IgnoredTaskMethodBuilder<T> Create() => new IgnoredTaskMethodBuilder<T>(new MyTask<T>());", "public static int Create() => 0;")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics();
+        }
+
+        [Fact]
+        public void BuilderOnMethod_IgnoreBadBuilderOnType_TaskPropertyReturnsInt()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+}}
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder))]
+{AwaitableTypeCode("MyTask")}
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder<>))]
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTask")
+    .Replace("public MyTask Task => _task;", "public int Task => 0;")}
+
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTask", "T")
+    .Replace("public MyTask<T> Task => _task;", "public int Task => 0;")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics();
+        }
+
+        [Fact]
+        public void BuilderOnMethod_IgnoreBadBuilderOnType_SetExceptionIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+}}
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder))]
+{AwaitableTypeCode("MyTask")}
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder<>))]
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTask")
+    .Replace("public void SetException", "internal void SetException")
+    .Replace("public void SetResult", "internal void SetResult")}
+
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTask", "T")
+    .Replace("public void SetException", "internal void SetException")
+    .Replace("public void SetResult", "internal void SetResult")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics();
+        }
+
+        [Fact]
+        public void BuilderOnMethod_IgnoreBadBuilderOnType_SetResultIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+}}
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder))]
+{AwaitableTypeCode("MyTask")}
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder<>))]
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTask")
+    .Replace("public void SetResult", "internal void SetResult")}
+
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTask", "T")
+    .Replace("public void SetResult", "internal void SetResult")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics();
+        }
+
+        [Theory]
+        [InlineData("typeof(MyTaskMethodBuilder)")]
+        [InlineData("typeof(object)")]
+        [InlineData("null")]
+        public void BuilderOnMethod_DummyBuilderOnType_OnLocalFunction(string dummyBuilder)
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Console.WriteLine(await M());
+
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+
+[AsyncMethodBuilder({dummyBuilder})]
+{AwaitableTypeCode("MyTask")}
+
+[AsyncMethodBuilder({dummyBuilder})]
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.Regular9);
+            compilation.VerifyDiagnostics(
+                // (9,21): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "F").WithArguments("async method builder override", "10.0").WithLocation(9, 21),
+                // (12,24): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "G").WithArguments("async method builder override", "10.0").WithLocation(12, 24),
+                // (15,26): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "M").WithArguments("async method builder override", "10.0").WithLocation(15, 26)
+                );
+
+            compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.Regular10);
+            var verifier = CompileAndVerify(compilation, expectedOutput: "M F G 3");
+            verifier.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void BuilderOnMethod_ErrorType()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(Error))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(Error<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(Error<>))]
+    public static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+{AwaitableTypeCode("MyTask")}
+
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,32): error CS0246: The type or namespace name 'Error' could not be found (are you missing a using directive or an assembly reference?)
+                //     [AsyncMethodBuilder(typeof(Error))]
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "Error").WithArguments("Error").WithLocation(8, 32),
+                // (11,32): error CS0246: The type or namespace name 'Error<>' could not be found (are you missing a using directive or an assembly reference?)
+                //     [AsyncMethodBuilder(typeof(Error<>))]
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "Error<>").WithArguments("Error<>").WithLocation(11, 32),
+                // (14,32): error CS0246: The type or namespace name 'Error<>' could not be found (are you missing a using directive or an assembly reference?)
+                //     [AsyncMethodBuilder(typeof(Error<>))]
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "Error<>").WithArguments("Error<>").WithLocation(14, 32)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_WrongArity()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    public static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+{AwaitableTypeCode("MyTask")}
+
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncMethodBuilderAttribute}
+";
+
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (9,29): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithLocation(9, 29),
+                // (12,38): error CS8940: A generic task-like return type was expected, but the type 'MyTaskMethodBuilder' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder").WithLocation(12, 38),
+                // (15,41): error CS8940: A generic task-like return type was expected, but the type 'MyTaskMethodBuilder' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
+                //     public static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder").WithLocation(15, 41)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_IgnoreBuilderTypeAccessibility()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+public class T1 {{ }}
+public class T2 {{ }}
+internal class T3 {{ }}
+internal class T4 {{ }}
+
+{AsyncBuilderCode("B1", "T1").Replace("public class B1", "public class B1")}
+{AsyncBuilderCode("B2", "T2").Replace("public class B2", "internal class B2")}
+{AsyncBuilderCode("B3", "T3").Replace("public class B3", "public class B3").Replace("public T3 Task =>", "internal T3 Task =>")}
+{AsyncBuilderCode("B4", "T4").Replace("public class B4", "internal class B4")}
+
+class Program
+{{
+    [AsyncMethodBuilder(typeof(B1))] public async T1 F1() => await Task.Delay(1);
+    [AsyncMethodBuilder(typeof(B2))] public async T2 F2() => await Task.Delay(2);
+    [AsyncMethodBuilder(typeof(B3))] internal async T3 F3() => await Task.Delay(3);
+    [AsyncMethodBuilder(typeof(B4))] internal async T4 F4() => await Task.Delay(4);
+}}
+
+{AsyncMethodBuilderAttribute}
+";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyEmitDiagnostics(
+                // (76,61): error CS0656: Missing compiler required member 'B3.Task'
+                //     [AsyncMethodBuilder(typeof(B3))] internal async T3 F3() => await Task.Delay(3);
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "=> await Task.Delay(3)").WithArguments("B3", "Task").WithLocation(76, 61)
+                );
+        }
+
+        [Fact]
+        public void BuilderFactoryOnMethod()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Console.WriteLine(await C.M());
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilderFactory))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilderFactory<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilderFactory<>))]
+    public static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{asyncBuilderFactoryCode("MyTaskMethodBuilder", "MyTask")}
+{asyncBuilderFactoryCode("MyTaskMethodBuilder", "MyTask", "T", isStruct: true)}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (11,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory.Create'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilderFactory", "Create").WithLocation(11, 29),
+                // (11,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory.Task'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilderFactory", "Task").WithLocation(11, 29),
+                // (14,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilderFactory<T>", "Create").WithLocation(14, 38),
+                // (14,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory<T>.Task'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilderFactory<T>", "Task").WithLocation(14, 38),
+                // (17,41): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory<int>.Create'
+                //     public static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilderFactory<int>", "Create").WithLocation(17, 41),
+                // (17,41): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory<int>.Task'
+                //     public static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilderFactory<int>", "Task").WithLocation(17, 41)
+                );
+
+            static string asyncBuilderFactoryCode(string builderTypeName, string tasklikeTypeName, string? genericTypeParameter = null, bool isStruct = false)
+            {
+                string ofT = genericTypeParameter == null ? "" : "<" + genericTypeParameter + ">";
+
+                return $@"
+public {(isStruct ? "struct" : "class")} {builderTypeName}Factory{ofT}
+{{
+    public static {builderTypeName}{ofT} Create() => new {builderTypeName}{ofT}(new {tasklikeTypeName}{ofT}());
+}}
+
+public {(isStruct ? "struct" : "class")} {builderTypeName}{ofT}
+{{
+    private {tasklikeTypeName}{ofT} _task;
+    internal {builderTypeName}({tasklikeTypeName}{ofT} task) {{ _task = task; }}
+    public void SetStateMachine(IAsyncStateMachine stateMachine) {{ }}
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine {{ stateMachine.MoveNext(); }}
+    public void SetException(Exception e) {{ }}
+    public void SetResult({(genericTypeParameter == null ? "" : genericTypeParameter + " result")}) {{ {(genericTypeParameter == null ? "" : "_task._result = result;")} }}
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public {tasklikeTypeName}{ofT} Task => _task;
+}}
+";
+            }
+        }
+
+        [Fact]
+        public void BuilderOnMethod_OnLambda()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Func<MyTask> f = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async () => {{ System.Console.Write(""F ""); await Task.Delay(0); }};
+
+Func<MyTask<int>> m = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] async () => {{ System.Console.Write(""M ""); await f(); return 3; }};
+
+Console.WriteLine(await m());
+return;
+
+{AwaitableTypeCode("MyTask", isStruct: true)}
+{AwaitableTypeCode("MyTask", "T", isStruct: true)}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", isStruct: true)}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T", isStruct: true)}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.Regular9);
+            compilation.VerifyEmitDiagnostics(
+                // (6,18): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask> f = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async () => { System.Console.Write("F "); await Task.Delay(0); };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]").WithArguments("lambda attributes", "10.0").WithLocation(6, 18),
+                // (6,84): error CS8935: The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.
+                // Func<MyTask> f = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async () => { System.Console.Write("F "); await Task.Delay(0); };
+                Diagnostic(ErrorCode.ERR_BuilderAttributeDisallowed, "=>").WithLocation(6, 84),
+                // (6,84): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask> f = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async () => { System.Console.Write("F "); await Task.Delay(0); };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "=>").WithArguments("async method builder override", "10.0").WithLocation(6, 84),
+                // (8,23): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask<int>> m = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] async () => { System.Console.Write("M "); await f(); return 3; };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]").WithArguments("lambda attributes", "10.0").WithLocation(8, 23),
+                // (8,84): error CS8935: The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.
+                // Func<MyTask<int>> m = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] async () => { System.Console.Write("M "); await f(); return 3; };
+                Diagnostic(ErrorCode.ERR_BuilderAttributeDisallowed, "=>").WithLocation(8, 84),
+                // (8,84): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask<int>> m = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] async () => { System.Console.Write("M "); await f(); return 3; };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "=>").WithArguments("async method builder override", "10.0").WithLocation(8, 84)
+                );
+            compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.Regular10);
+            compilation.VerifyEmitDiagnostics(
+                // (6,84): error CS8933: The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.
+                // Func<MyTask> f = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async () => { System.Console.Write("F "); await Task.Delay(0); };
+                Diagnostic(ErrorCode.ERR_BuilderAttributeDisallowed, "=>").WithLocation(6, 84),
+                // (8,84): error CS8933: The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.
+                // Func<MyTask<int>> m = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] async () => { System.Console.Write("M "); await f(); return 3; };
+                Diagnostic(ErrorCode.ERR_BuilderAttributeDisallowed, "=>").WithLocation(8, 84)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_OnLambda_WithExplicitType()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Func<MyTask> f = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async MyTask () => {{ System.Console.Write(""F ""); await Task.Delay(0); }};
+
+Func<MyTask<int>> m = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] async MyTask<int> () => {{ System.Console.Write(""M ""); await f(); return 3; }};
+
+Console.WriteLine(await m());
+return;
+
+{AwaitableTypeCode("MyTask", isStruct: true)}
+{AwaitableTypeCode("MyTask", "T", isStruct: true)}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", isStruct: true)}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T", isStruct: true)}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.Regular9);
+            compilation.VerifyEmitDiagnostics(
+                // (6,18): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask> f = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async MyTask () => { System.Console.Write("F "); await Task.Delay(0); };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]").WithArguments("lambda attributes", "10.0").WithLocation(6, 18),
+                // (6,81): error CS8773: Feature 'lambda return type' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask> f = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async MyTask () => { System.Console.Write("F "); await Task.Delay(0); };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "MyTask").WithArguments("lambda return type", "10.0").WithLocation(6, 81),
+                // (6,91): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask> f = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async MyTask () => { System.Console.Write("F "); await Task.Delay(0); };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "=>").WithArguments("async method builder override", "10.0").WithLocation(6, 91),
+                // (8,23): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask<int>> m = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] async MyTask<int> () => { System.Console.Write("M "); await f(); return 3; };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]").WithArguments("lambda attributes", "10.0").WithLocation(8, 23),
+                // (8,81): error CS8773: Feature 'lambda return type' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask<int>> m = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] async MyTask<int> () => { System.Console.Write("M "); await f(); return 3; };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "MyTask<int>").WithArguments("lambda return type", "10.0").WithLocation(8, 81),
+                // (8,96): error CS8773: Feature 'async method builder override' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // Func<MyTask<int>> m = [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] async MyTask<int> () => { System.Console.Write("M "); await f(); return 3; };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "=>").WithArguments("async method builder override", "10.0").WithLocation(8, 96)
+                );
+
+            compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.Regular10);
+            var verifier = CompileAndVerify(compilation, expectedOutput: "M F 3");
+            verifier.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void BuilderOnMethod_OnLambda_NotTaskLikeTypes_InferReturnType()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+C.F(
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async () => {{ System.Console.Write(""Lambda1 ""); await Task.Delay(0); }} // 1
+);
+
+C.F(
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] static async () => {{ System.Console.Write(""Lambda2 ""); await Task.Delay(0); return 3; }} // 2
+);
+
+await Task.Delay(0);
+return;
+
+public class C
+{{
+    public static void F(Func<MyTask> f) {{ System.Console.Write(""Overload1 ""); f().GetAwaiter().GetResult(); }}
+    public static void F<T>(Func<MyTask<T>> f) {{ System.Console.Write(""Overload2 ""); f().GetAwaiter().GetResult(); }}
+    public static void F(Func<MyTask<string>> f) {{ System.Console.Write(""Overload3 ""); f().GetAwaiter().GetResult(); }}
+}}
+
+// no attribute
+{AwaitableTypeCode("MyTask", isStruct: true)}
+
+// no attribute
+{AwaitableTypeCode("MyTask", "T", isStruct: true)}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", isStruct: true)}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T", isStruct: true)}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (7,71): error CS8935: The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.
+                //     [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async () => { System.Console.Write("Lambda1 "); await Task.Delay(0); } // 1
+                Diagnostic(ErrorCode.ERR_BuilderAttributeDisallowed, "=>").WithLocation(7, 71),
+                // (11,73): error CS8935: The AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.
+                //     [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] static async () => { System.Console.Write("Lambda2 "); await Task.Delay(0); return 3; } // 2
+                Diagnostic(ErrorCode.ERR_BuilderAttributeDisallowed, "=>").WithLocation(11, 73)
+                );
+
+            var tree = compilation.SyntaxTrees.Single();
+            var model = compilation.GetSemanticModel(tree, ignoreAccessibility: false);
+            var lambdas = tree.GetRoot().DescendantNodes().OfType<LambdaExpressionSyntax>().ToArray();
+            var firstLambda = model.GetTypeInfo(lambdas[0]);
+            Assert.Null(firstLambda.Type);
+            Assert.Equal("System.Func<MyTask>", firstLambda.ConvertedType.ToTestDisplayString());
+
+            var secondLambda = model.GetTypeInfo(lambdas[1]);
+            Assert.Null(secondLambda.Type);
+            Assert.Equal("System.Func<MyTask>", secondLambda.ConvertedType.ToTestDisplayString());
+        }
+
+        [Fact]
+        public void BuilderOnMethod_OnLambda_NotTaskLikeTypes_ExplicitReturnType()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+C.F(
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))] static async MyTask () => {{ System.Console.Write(""Lambda1 ""); await Task.Delay(0); }} // 1
+);
+
+C.F(
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))] static async MyTask<int> () => {{ System.Console.Write(""Lambda2 ""); await Task.Delay(0); return 3; }} // 2
+);
+
+await Task.Delay(0);
+return;
+
+public class C
+{{
+    public static void F(Func<MyTask> f) {{ System.Console.Write(""Overload1 ""); f().GetAwaiter().GetResult(); }}
+    public static void F<T>(Func<MyTask<T>> f) {{ System.Console.Write(""Overload2 ""); f().GetAwaiter().GetResult(); }}
+    public static void F(Func<MyTask<string>> f) {{ System.Console.Write(""Overload3 ""); f().GetAwaiter().GetResult(); }}
+}}
+
+// no attribute
+{AwaitableTypeCode("MyTask", isStruct: true)}
+
+// no attribute
+{AwaitableTypeCode("MyTask", "T", isStruct: true)}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", isStruct: true)}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T", isStruct: true)}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            var verifier = CompileAndVerify(compilation, expectedOutput: "Overload1 Lambda1 Overload2 Lambda2");
+            verifier.VerifyDiagnostics();
+
+            var tree = compilation.SyntaxTrees.Single();
+            var model = compilation.GetSemanticModel(tree, ignoreAccessibility: false);
+            var lambdas = tree.GetRoot().DescendantNodes().OfType<LambdaExpressionSyntax>().ToArray();
+            var firstLambda = model.GetTypeInfo(lambdas[0]);
+            Assert.Null(firstLambda.Type);
+            Assert.Equal("System.Func<MyTask>", firstLambda.ConvertedType.ToTestDisplayString());
+
+            var secondLambda = model.GetTypeInfo(lambdas[1]);
+            Assert.Null(secondLambda.Type);
+            Assert.Equal("System.Func<MyTask<System.Int32>>", secondLambda.ConvertedType.ToTestDisplayString());
+        }
+
+        [Fact]
+        public void BuilderOnMethod_TaskPropertyHasObjectType()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public MyTask Task", "public object Task")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public MyTask<T> Task", "public object Task")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyDiagnostics();
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS8204: For type 'MyTaskMethodBuilder' to be used as an AsyncMethodBuilder for type 'MyTask', its Task property should return type 'MyTask' instead of type 'object'.
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_BadAsyncMethodBuilderTaskProperty, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "MyTask", "object").WithLocation(8, 29),
+                // (11,38): error CS8204: For type 'MyTaskMethodBuilder<T>' to be used as an AsyncMethodBuilder for type 'MyTask<T>', its Task property should return type 'MyTask<T>' instead of type 'object'.
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_BadAsyncMethodBuilderTaskProperty, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "MyTask<T>", "object").WithLocation(11, 38),
+                // (14,34): error CS8204: For type 'MyTaskMethodBuilder<int>' to be used as an AsyncMethodBuilder for type 'MyTask<int>', its Task property should return type 'MyTask<int>' instead of type 'object'.
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_BadAsyncMethodBuilderTaskProperty, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "MyTask<int>", "object").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_CreateMissing()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")
+    .Replace("public static MyTaskMethodBuilder Create() => new MyTaskMethodBuilder(new MyTask());", "")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")
+    .Replace("public static MyTaskMethodBuilder<T> Create() => new MyTaskMethodBuilder<T>(new MyTask<T>());", "")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyDiagnostics();
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Create'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Create").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Create").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Create'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Create").WithLocation(14, 34)
+                );
+        }
+
+        [Theory]
+        [InlineData("internal")]
+        [InlineData("private")]
+        public void BuilderOnMethod_CreateNotPublic(string accessibility)
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public static MyTaskMethodBuilder Create()", accessibility + " static MyTaskMethodBuilder Create()")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public static MyTaskMethodBuilder<T> Create()", accessibility + " static MyTaskMethodBuilder<T> Create()")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Create'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Create").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Create").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Create'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Create").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_CreateNotStatic()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public static MyTaskMethodBuilder Create()", "public MyTaskMethodBuilder Create()")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public static MyTaskMethodBuilder<T> Create()", "public MyTaskMethodBuilder<T> Create()")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyDiagnostics();
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Create'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Create").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Create").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Create'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Create").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_CreateHasParameter()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public static MyTaskMethodBuilder Create()", "public static MyTaskMethodBuilder Create(int i)")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public static MyTaskMethodBuilder<T> Create()", "public static MyTaskMethodBuilder<T> Create(int i)")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyDiagnostics();
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Create'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Create").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Create").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Create'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Create").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_CreateIsGeneric()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public static MyTaskMethodBuilder Create()", "public static MyTaskMethodBuilder Create<U>()")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public static MyTaskMethodBuilder<T> Create()", "public static MyTaskMethodBuilder<T> Create<U>()")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyDiagnostics();
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Create'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Create").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Create").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Create'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Create").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_CreateHasRefReturn()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")
+    .Replace(
+        "public static MyTaskMethodBuilder Create() => new MyTaskMethodBuilder(new MyTask());",
+        "public static ref MyTaskMethodBuilder Create() => throw null;")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")
+    .Replace(
+        "public static MyTaskMethodBuilder<T> Create() => new MyTaskMethodBuilder<T>(new MyTask<T>());",
+        "public static ref MyTaskMethodBuilder<T> Create() => throw null;")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyDiagnostics();
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Create'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Create").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Create").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Create'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Create").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_BuilderIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Console.WriteLine(await C.M());
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    public static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public class MyTaskMethodBuilder", "internal class MyTaskMethodBuilder")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public class MyTaskMethodBuilder<T>", "internal class MyTaskMethodBuilder<T>")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            CompileAndVerify(compilation, expectedOutput: "M F G 3");
+        }
+
+        [Fact]
+        public void BuilderOnMethod_BuilderIsPrivate()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Console.WriteLine(await C.M());
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    public static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+
+    {AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public class MyTaskMethodBuilder", "private class MyTaskMethodBuilder")}
+    {AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public class MyTaskMethodBuilder<T>", "private class MyTaskMethodBuilder<T>")}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            CompileAndVerify(compilation, expectedOutput: "M F G 3");
+        }
+
+        [Fact]
+        public void BuilderOnMethod_CreateIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public static MyTaskMethodBuilder Create()", "internal static MyTaskMethodBuilder Create()")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public static MyTaskMethodBuilder<T> Create()", "internal static MyTaskMethodBuilder<T> Create()")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Create'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Create").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Create").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Create'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Create").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_TwoMethodLevelAttributes()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Console.WriteLine(await C.M());
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    [AsyncMethodBuilder(null)]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    [AsyncMethodBuilder(null)]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    [AsyncMethodBuilder(null)]
+    public static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", isStruct: true)}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T", isStruct: true)}
+
+namespace System.Runtime.CompilerServices
+{{
+    [System.AttributeUsage(System.AttributeTargets.All, AllowMultiple=true)]
+    class AsyncMethodBuilderAttribute : System.Attribute {{ public AsyncMethodBuilderAttribute(System.Type t) {{ }} }}
+}}
+";
+            // The first attribute is used
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: "M F G 3");
+        }
+
+        [Fact]
+        public void BuilderOnMethod_TwoMethodLevelAttributes_ReverseOrder()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{{
+    [AsyncMethodBuilder(null)]
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(null)]
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(null)]
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+namespace System.Runtime.CompilerServices
+{{
+    [System.AttributeUsage(System.AttributeTargets.All, AllowMultiple=true)]
+    class AsyncMethodBuilderAttribute : System.Attribute {{ public AsyncMethodBuilderAttribute(System.Type t) {{ }} }}
+}}
+";
+            // The first attribute is used
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (10,29): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithLocation(10, 29),
+                // (14,38): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithLocation(14, 38),
+                // (18,34): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithLocation(18, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_BoundGeneric_TypeParameter()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C<U>
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<U>))]
+    static async MyTask<U> G<T>(T t) {{ await Task.Delay(0); throw null; }}
+}}
+
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,25): error CS0416: 'MyTaskMethodBuilder<U>': an attribute argument cannot use type parameters
+                //     [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<U>))]
+                Diagnostic(ErrorCode.ERR_AttrArgWithTypeVars, "typeof(MyTaskMethodBuilder<U>)").WithArguments("MyTaskMethodBuilder<U>").WithLocation(8, 25)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_BoundGeneric_SpecificType()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C<U>
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<int>))]
+    static async MyTask<int> M() {{ await Task.Delay(0); throw null; }}
+}}
+
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source);
+            compilation.VerifyEmitDiagnostics(
+                // (9,34): error CS8940: A generic task-like return type was expected, but the type 'MyTaskMethodBuilder<int>' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
+                //     static async MyTask<int> M() { await Task.Delay(0); throw null; }
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, "{ await Task.Delay(0); throw null; }").WithArguments("MyTaskMethodBuilder<int>").WithLocation(9, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_TaskPropertyIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public MyTask Task =>", "internal MyTask Task =>")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public MyTask<T> Task =>", "internal MyTask<T> Task =>")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Task'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Task").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Task'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Task").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Task'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Task").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_TaskPropertyIsStatic()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public MyTask Task => _task;", "public static MyTask Task => throw null;")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public MyTask<T> Task => _task;", "public static MyTask<T> Task => throw null;")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Task'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Task").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Task'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Task").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Task'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Task").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_TaskPropertyIsField()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public MyTask Task => _task;", "public static MyTask Task = null;")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public MyTask<T> Task => _task;", "public MyTask<T> Task = null;")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Task'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Task").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Task'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Task").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Task'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Task").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_SetExceptionIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public void SetException", "internal void SetException")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public void SetException", "internal void SetException")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.SetException'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "SetException").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.SetException'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "SetException").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.SetException'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "SetException").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_SetExceptionReturnsObject()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask")
+    .Replace("public void SetException(System.Exception e) { }", "public object SetException(System.Exception e) => null;")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T")
+    .Replace("public void SetException(System.Exception e) { }", "public object SetException(System.Exception e) => null;")}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.SetException'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "SetException").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.SetException'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "SetException").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.SetException'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "SetException").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_SetExceptionLacksParameter()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public void SetException(System.Exception e)", "public void SetException()")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public void SetException(System.Exception e)", "public void SetException()")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.SetException'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "SetException").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.SetException'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "SetException").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.SetException'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "SetException").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_SetResultIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public void SetResult", "internal void SetResult")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public void SetResult", "internal void SetResult")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.SetResult'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "SetResult").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.SetResult'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "SetResult").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.SetResult'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "SetResult").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_AwaitOnCompletedIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public void AwaitOnCompleted", "internal void AwaitOnCompleted")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public void AwaitOnCompleted", "internal void AwaitOnCompleted")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.AwaitOnCompleted'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "AwaitOnCompleted").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.AwaitOnCompleted'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "AwaitOnCompleted").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.AwaitOnCompleted'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "AwaitOnCompleted").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_AwaitUnsafeOnCompletedIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public void AwaitUnsafeOnCompleted", "internal void AwaitUnsafeOnCompleted")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public void AwaitUnsafeOnCompleted", "internal void AwaitUnsafeOnCompleted")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.AwaitUnsafeOnCompleted'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "AwaitUnsafeOnCompleted").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.AwaitUnsafeOnCompleted'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "AwaitUnsafeOnCompleted").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.AwaitUnsafeOnCompleted'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "AwaitUnsafeOnCompleted").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_StartIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public void Start", "internal void Start")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public void Start", "internal void Start")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Start'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Start").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Start'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Start").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Start'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Start").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_SetStateMachineIsInternal()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async MyTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async MyTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+{AwaitableTypeCode("MyTask")}
+{AwaitableTypeCode("MyTask", "T")}
+
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask").Replace("public void SetStateMachine", "internal void SetStateMachine")}
+{AsyncBuilderCode("MyTaskMethodBuilder", "MyTask", "T").Replace("public void SetStateMachine", "internal void SetStateMachine")}
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (8,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.SetStateMachine'
+                //     static async MyTask F() { System.Console.Write("F "); await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""F ""); await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "SetStateMachine").WithLocation(8, 29),
+                // (11,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.SetStateMachine'
+                //     static async MyTask<T> G<T>(T t) { System.Console.Write("G "); await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""G ""); await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "SetStateMachine").WithLocation(11, 38),
+                // (14,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.SetStateMachine'
+                //     static async MyTask<int> M() { System.Console.Write("M "); await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, @"{ System.Console.Write(""M ""); await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "SetStateMachine").WithLocation(14, 34)
+                );
+        }
+
+        [Fact]
+        public void BuilderOnMethod_AsyncMethodReturnsTask()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Console.WriteLine(await C.M());
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async Task F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async Task<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    public static async Task<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+public class MyTaskMethodBuilder
+{{
+    public static MyTaskMethodBuilder Create() => new MyTaskMethodBuilder();
+    internal MyTaskMethodBuilder() {{ }}
+    public void SetStateMachine(IAsyncStateMachine stateMachine) {{ }}
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine {{ stateMachine.MoveNext(); }}
+    public void SetException(Exception e) {{ }}
+    public void SetResult() {{  }}
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public Task Task => System.Threading.Tasks.Task.CompletedTask;
+}}
+
+public class MyTaskMethodBuilder<T>
+{{
+    public static MyTaskMethodBuilder<T> Create() => new MyTaskMethodBuilder<T>();
+    private TaskCompletionSource<T> _taskCompletionSource = new TaskCompletionSource<T>();
+    internal MyTaskMethodBuilder() {{ }}
+    public void SetStateMachine(IAsyncStateMachine stateMachine) {{ }}
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine {{ stateMachine.MoveNext(); }}
+    public void SetException(Exception e) {{ }}
+    public void SetResult(T result) {{ _taskCompletionSource.SetResult(result); }}
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public Task<T> Task => _taskCompletionSource.Task;
+}}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: "M F G 3");
+        }
+
+        [Fact]
+        public void BuilderOnMethod_AsyncMethodReturnsValueTask()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+Console.WriteLine(await C.M());
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+    static async ValueTask F() {{ System.Console.Write(""F ""); await Task.Delay(0); }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    static async ValueTask<T> G<T>(T t) {{ System.Console.Write(""G ""); await Task.Delay(0); return t; }}
+
+    [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+    public static async ValueTask<int> M() {{ System.Console.Write(""M ""); await F(); return await G(3); }}
+}}
+
+public class MyTaskMethodBuilder
+{{
+    public static MyTaskMethodBuilder Create() => new MyTaskMethodBuilder();
+    internal MyTaskMethodBuilder() {{ }}
+    public void SetStateMachine(IAsyncStateMachine stateMachine) {{ }}
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine {{ stateMachine.MoveNext(); }}
+    public void SetException(Exception e) {{ }}
+    public void SetResult() {{  }}
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public ValueTask Task => new ValueTask(System.Threading.Tasks.Task.CompletedTask);
+}}
+
+public class MyTaskMethodBuilder<T>
+{{
+    public static MyTaskMethodBuilder<T> Create() => new MyTaskMethodBuilder<T>();
+    private TaskCompletionSource<T> _taskCompletionSource = new TaskCompletionSource<T>();
+    internal MyTaskMethodBuilder() {{ }}
+    public void SetStateMachine(IAsyncStateMachine stateMachine) {{ }}
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine {{ stateMachine.MoveNext(); }}
+    public void SetException(Exception e) {{ }}
+    public void SetResult(T result) {{ _taskCompletionSource.SetResult(result); }}
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public ValueTask<T> Task => new ValueTask<T>(_taskCompletionSource.Task);
+}}
+
+{AsyncMethodBuilderAttribute}
+";
+            var compilation = CreateCompilationWithTasksExtensions(source, parseOptions: TestOptions.RegularPreview);
+            compilation.VerifyEmitDiagnostics(
+                // (10,6): warning CS0436: The type 'AsyncMethodBuilderAttribute' in '' conflicts with the imported type 'AsyncMethodBuilderAttribute' in 'System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51'. Using the type defined in ''.
+                //     [AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "AsyncMethodBuilder").WithArguments("", "System.Runtime.CompilerServices.AsyncMethodBuilderAttribute", "System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51", "System.Runtime.CompilerServices.AsyncMethodBuilderAttribute").WithLocation(10, 6),
+                // (13,6): warning CS0436: The type 'AsyncMethodBuilderAttribute' in '' conflicts with the imported type 'AsyncMethodBuilderAttribute' in 'System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51'. Using the type defined in ''.
+                //     [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "AsyncMethodBuilder").WithArguments("", "System.Runtime.CompilerServices.AsyncMethodBuilderAttribute", "System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51", "System.Runtime.CompilerServices.AsyncMethodBuilderAttribute").WithLocation(13, 6),
+                // (16,6): warning CS0436: The type 'AsyncMethodBuilderAttribute' in '' conflicts with the imported type 'AsyncMethodBuilderAttribute' in 'System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51'. Using the type defined in ''.
+                //     [AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "AsyncMethodBuilder").WithArguments("", "System.Runtime.CompilerServices.AsyncMethodBuilderAttribute", "System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51", "System.Runtime.CompilerServices.AsyncMethodBuilderAttribute").WithLocation(16, 6)
+                );
+            CompileAndVerify(compilation, expectedOutput: "M F G 3");
+        }
+
+        [Fact]
+        public void BuilderOnMethod_InternalReturnType()
+        {
+            var source = $@"
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+[AsyncMethodBuilder(null)] internal class MyTaskType {{ }}
+
+// Make the builder factory and the builder internal as well
+{AsyncBuilderCode("MyTaskTypeBuilder", "MyTaskType").Replace("public class MyTaskType", "internal class MyTaskType") }
+
+class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskTypeBuilder))]
+    async MyTaskType M() => await Task.Delay(4);
+}}
+
+{AsyncMethodBuilderAttribute}
+";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyEmitDiagnostics();
+        }
+
+        [Fact]
+        public void BuilderOnMethod_IntReturnType()
+        {
+            var source = $@"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+System.Console.Write(new C().M());
+
+[AsyncMethodBuilder(typeof(IgnoredTaskMethodBuilder))] public class MyTaskType {{ }}
+
+public class C
+{{
+    [AsyncMethodBuilder(typeof(MyTaskTypeBuilder))]
+    public async int M() => await Task.Delay(4);
+}}
+
+public class MyTaskTypeBuilder
+{{
+    public static MyTaskTypeBuilder Create() => new MyTaskTypeBuilder();
+    public void SetStateMachine(IAsyncStateMachine stateMachine) {{ }}
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine {{ stateMachine.MoveNext(); }}
+    public void SetException(Exception e) {{ }}
+    public void SetResult() {{  }}
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine {{ }}
+    public int Task => 42;
+}}
+
+{AsyncBuilderCode("IgnoredTaskMethodBuilder", "MyTaskType")}
+{AsyncMethodBuilderAttribute}
+";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            var verifier = CompileAndVerify(comp, expectedOutput: "42");
+            verifier.VerifyDiagnostics();
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncTests.cs
index cb53e0e9ce146..77028be86a8c4 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncTests.cs
@@ -3343,11 +3343,11 @@ namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute :
 ";
             var comp = CreateCompilation(source, options: TestOptions.DebugExe);
             comp.VerifyEmitDiagnostics(
-                // (17,27): error CS1983: The return type of an async method must be void, Task or Task<T>
-                //     async T_NIT<int> f1() => await Task.FromResult(1);
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(17, 27),
-                // (18,22): error CS1983: The return type of an async method must be void, Task or Task<T>
-                //     async T_NIN f2() => await Task.FromResult(1);
+                // (17,27): error CS8940: A generic task-like return type was expected, but the type 'N.BG<int>' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
+                //     async T_NIT<int> f1() => await Task.FromResult(1); 
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, "=> await Task.FromResult(1)").WithArguments("N.BG<int>").WithLocation(17, 27),
+                // (18,22): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
+                //     async T_NIN f2() => await Task.FromResult(1);      
                 Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(18, 22),
                 // (19,27): error CS0656: Missing compiler required member 'N.BG<int>.Task'
                 //     async T_NOT<int> f3() => await Task.FromResult(1); // ok builderType genericity (but missing members)
@@ -3355,40 +3355,40 @@ namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute :
                 // (19,27): error CS0656: Missing compiler required member 'N.BG<int>.Create'
                 //     async T_NOT<int> f3() => await Task.FromResult(1); // ok builderType genericity (but missing members)
                 Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "=> await Task.FromResult(1)").WithArguments("N.BG<int>", "Create").WithLocation(19, 27),
-                // (20,22): error CS1983: The return type of an async method must be void, Task or Task<T>
-                //     async T_NON f4() => await Task.FromResult(1);
+                // (20,22): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
+                //     async T_NON f4() => await Task.FromResult(1);      
                 Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(20, 22),
-                // (21,27): error CS1983: The return type of an async method must be void, Task or Task<T>
-                //     async T_NNT<int> f5() => await Task.FromResult(1);
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(21, 27),
+                // (21,27): error CS8940: A generic task-like return type was expected, but the type 'N.BN' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
+                //     async T_NNT<int> f5() => await Task.FromResult(1); 
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, "=> await Task.FromResult(1)").WithArguments("N.BN").WithLocation(21, 27),
                 // (22,22): error CS0656: Missing compiler required member 'N.BN.Task'
                 //     async T_NNN f6() => await Task.FromResult(1);      // ok builderType genericity (but missing members)
                 Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "=> await Task.FromResult(1)").WithArguments("N.BN", "Task").WithLocation(22, 22),
                 // (22,22): error CS0656: Missing compiler required member 'N.BN.Create'
                 //     async T_NNN f6() => await Task.FromResult(1);      // ok builderType genericity (but missing members)
                 Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "=> await Task.FromResult(1)").WithArguments("N.BN", "Create").WithLocation(22, 22),
-                // (39,27): error CS1983: The return type of an async method must be void, Task or Task<T>
+                // (39,27): error CS8940: A generic task-like return type was expected, but the type 'G<int>.BG<int>' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
                 //     async T_IIT<int> g1() => await Task.FromResult(1);
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(39, 27),
-                // (40,22): error CS1983: The return type of an async method must be void, Task or Task<T>
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, "=> await Task.FromResult(1)").WithArguments("G<int>.BG<int>").WithLocation(39, 27),
+                // (40,22): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
                 //     async T_IIN g2() => await Task.FromResult(1);
                 Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(40, 22),
-                // (41,27): error CS1983: The return type of an async method must be void, Task or Task<T>
+                // (41,27): error CS8940: A generic task-like return type was expected, but the type 'G<int>.BN' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
                 //     async T_INT<int> g3() => await Task.FromResult(1);
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(41, 27),
-                // (42,22): error CS1983: The return type of an async method must be void, Task or Task<T>
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, "=> await Task.FromResult(1)").WithArguments("G<int>.BN").WithLocation(41, 27),
+                // (42,22): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
                 //     async T_INN g4() => await Task.FromResult(1);      // might have been ok builder genericity but we decided not
                 Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(42, 22),
-                // (43,27): error CS1983: The return type of an async method must be void, Task or Task<T>
+                // (43,27): error CS8940: A generic task-like return type was expected, but the type 'G<>.BG<>' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
                 //     async T_OOT<int> g5() => await Task.FromResult(1);
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(43, 27),
-                // (44,22): error CS1983: The return type of an async method must be void, Task or Task<T>
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, "=> await Task.FromResult(1)").WithArguments("G<>.BG<>").WithLocation(43, 27),
+                // (44,22): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
                 //     async T_OON g6() => await Task.FromResult(1);
                 Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(44, 22),
-                // (45,27): error CS1983: The return type of an async method must be void, Task or Task<T>
+                // (45,27): error CS8940: A generic task-like return type was expected, but the type 'G<>.BN' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
                 //     async T_ONT<int> g7() => await Task.FromResult(1);
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(45, 27),
-                // (46,22): error CS1983: The return type of an async method must be void, Task or Task<T>
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, "=> await Task.FromResult(1)").WithArguments("G<>.BN").WithLocation(45, 27),
+                // (46,22): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
                 //     async T_ONN g8() => await Task.FromResult(1);
                 Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=> await Task.FromResult(1)").WithLocation(46, 22)
                 );
@@ -3824,9 +3824,9 @@ namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute :
 ";
             var comp = CreateCompilationWithMscorlib45(source);
             comp.VerifyEmitDiagnostics(
-                // (5,30): error CS1983: The return type of an async method must be void, Task or Task<T>
+                // (5,30): error CS8940: A generic task-like return type was expected, but the type 'Mismatch1MethodBuilder' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
                 //     async Mismatch1<int> f() { await (Task)null; return 1; }
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "{ await (Task)null; return 1; }").WithLocation(5, 30),
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, "{ await (Task)null; return 1; }").WithArguments("Mismatch1MethodBuilder").WithLocation(5, 30),
                 // (6,45): error CS1997: Since 'C.g()' is an async method that returns 'Task', a return keyword must not be followed by an object expression. Did you intend to return 'Task<T>'?
                 //     async Mismatch2 g() { await (Task)null; return 1; }
                 Diagnostic(ErrorCode.ERR_TaskRetNoObjectRequired, "return").WithArguments("C.g()").WithLocation(6, 45)
@@ -4828,9 +4828,9 @@ public class AsyncMethodBuilderAttribute : System.Attribute { public AsyncMethod
 }";
             var compilation = CreateCompilation(source, options: TestOptions.DebugDll);
             compilation.VerifyEmitDiagnostics(
-                // (8,53): error CS1983: The return type of an async method must be void, Task or Task<T>
+                // (8,53): error CS8940: A generic task-like return type was expected, but the type 'CustomAsyncTaskMethodBuilder<,>' found in 'AsyncMethodBuilder' attribute was not suitable. It must be an unbound generic type of arity one, and its containing type (if any) must be non-generic.
                 //     public async MyAwesomeType<string> CustomTask() { await Task.Delay(1000); return string.Empty; }
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "{ await Task.Delay(1000); return string.Empty; }").WithLocation(8, 53)
+                Diagnostic(ErrorCode.ERR_WrongArityAsyncReturn, "{ await Task.Delay(1000); return string.Empty; }").WithArguments("CustomAsyncTaskMethodBuilder<,>").WithLocation(8, 53)
                 );
         }
 
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDeconstructTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDeconstructTests.cs
index d47cd7fb86dc5..144ab5ebf7656 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDeconstructTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDeconstructTests.cs
@@ -6168,12 +6168,12 @@ static void Main()
 
             var comp = CreateCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (6,9): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (6,9): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         (@_, var x) = (1, 2);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(@_, var x) = (1, 2)", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(6, 9),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(@_, var x) = (1, 2)").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(6, 9),
                 // (6,10): error CS0103: The name '_' does not exist in the current context
                 //         (@_, var x) = (1, 2);
-                Diagnostic(ErrorCode.ERR_NameNotInContext, "@_", isSuppressed: false).WithArguments("_").WithLocation(6, 10)
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "@_").WithArguments("_").WithLocation(6, 10)
                 );
 
             var tree = comp.SyntaxTrees.First();
@@ -6716,21 +6716,21 @@ static void Main()
 ";
             var compCSharp9 = CreateCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular9);
             compCSharp9.VerifyDiagnostics(
-                // (6,9): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (6,9): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         (var x, x) = (1, 2);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(var x, x) = (1, 2)", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(6, 9),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(var x, x) = (1, 2)").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(6, 9),
                 // (6,17): error CS0841: Cannot use local variable 'x' before it is declared
                 //         (var x, x) = (1, 2);
-                Diagnostic(ErrorCode.ERR_VariableUsedBeforeDeclaration, "x", isSuppressed: false).WithArguments("x").WithLocation(6, 17),
-                // (7,9): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_VariableUsedBeforeDeclaration, "x").WithArguments("x").WithLocation(6, 17),
+                // (7,9): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         (y, var y) = (1, 2);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(y, var y) = (1, 2)", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(7, 9),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(y, var y) = (1, 2)").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(7, 9),
                 // (7,10): error CS0841: Cannot use local variable 'y' before it is declared
                 //         (y, var y) = (1, 2);
-                Diagnostic(ErrorCode.ERR_VariableUsedBeforeDeclaration, "y", isSuppressed: false).WithArguments("y").WithLocation(7, 10)
+                Diagnostic(ErrorCode.ERR_VariableUsedBeforeDeclaration, "y").WithArguments("y").WithLocation(7, 10)
                 );
 
-            var comp = CreateCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.RegularPreview);
+            var comp = CreateCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics(
                 // (6,17): error CS0841: Cannot use local variable 'x' before it is declared
                 //         (var x, x) = (1, 2);
@@ -7231,9 +7231,9 @@ static void Main(string[] args)
 }";
             var compilation = CreateCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular9);
             compilation.VerifyDiagnostics(
-                // (8,14): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (8,14): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         for ((int x1, z) = t; ; )
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(int x1, z) = t", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(8, 14));
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(int x1, z) = t").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(8, 14));
 
             var tree = compilation.SyntaxTrees.First();
             var model = compilation.GetSemanticModel(tree);
@@ -9933,18 +9933,18 @@ public void Deconstruct(out int a, out (string b, bool c) tuple)
 }
 ";
             CreateCompilation(source, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
-                // (7,9): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (7,9): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         (x1, string y1) = new A();
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(x1, string y1) = new A()", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(7, 9),
-                // (9,9): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(x1, string y1) = new A()").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(7, 9),
+                // (9,9): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         (int x2, y2) = new A();
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(int x2, y2) = new A()", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(9, 9),
-                // (11,9): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(int x2, y2) = new A()").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(9, 9),
+                // (11,9): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         (int x3, (string y3, z3)) = new B();
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(int x3, (string y3, z3)) = new B()", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(11, 9),
-                // (13,9): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(int x3, (string y3, z3)) = new B()").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(11, 9),
+                // (13,9): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         (x4, var (y4, z4)) = new B();
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(x4, var (y4, z4)) = new B()", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(13, 9));
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(x4, var (y4, z4)) = new B()").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(13, 9));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs
index 9e638053b093a..8433400cbb5d0 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs
@@ -7787,10 +7787,10 @@ void local() {}
 ", UnmanagedCallersOnlyAttribute });
 
             comp.VerifyDiagnostics(
-                // (6,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (6,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //     [UnmanagedCallersOnly]
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(6, 6),
-                // (11,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (11,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //         [UnmanagedCallersOnly]
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(11, 10)
             );
@@ -8687,6 +8687,51 @@ public static void M2(C c)
             );
         }
 
+        [Fact]
+        [WorkItem(54113, "https://github.com/dotnet/roslyn/issues/54113")]
+        public void UnmanagedCallersOnlyDefinedOnConversion()
+        {
+            var il = UnmanagedCallersOnlyAttributeIl + @"
+.class public auto ansi beforefieldinit C
+    extends [mscorlib]System.Object
+{
+    .method public hidebysig specialname static 
+        int32 op_Implicit (
+            class C i
+        ) cil managed 
+    {
+        // [System.Runtime.InteropServices.UnmanagedCallersOnly]
+        .custom instance void System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute::.ctor() = (
+            01 00 00 00
+        )
+
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void [mscorlib]System.Object::.ctor()
+        IL_0006: nop
+        IL_0007: ret
+    }
+}
+";
+            var comp = CreateCompilationWithIL(@"
+class Test
+{
+    void M(C x)
+    {
+        _ = (int)x;
+    }
+}
+", il);
+
+            comp.VerifyDiagnostics();
+        }
+
         [Fact]
         public void UnmanagedCallersOnlyDefinedOnProperty_InSource()
         {
@@ -8708,10 +8753,10 @@ static void M()
 ", UnmanagedCallersOnlyAttribute });
 
             comp.VerifyDiagnostics(
-                // (7,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (7,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //         [UnmanagedCallersOnly] get => throw null;
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(7, 10),
-                // (8,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (8,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //         [UnmanagedCallersOnly] set => throw null;
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(8, 10)
             );
@@ -8793,7 +8838,7 @@ static void M()
 ", UnmanagedCallersOnlyAttribute });
 
             comp.VerifyDiagnostics(
-                // (5,28): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (5,28): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //     static int Prop { [UnmanagedCallersOnly] get {} }
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(5, 28)
             );
@@ -8933,10 +8978,10 @@ static void M(C c)
 ", UnmanagedCallersOnlyAttribute });
 
             comp.VerifyDiagnostics(
-                // (7,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (7,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //         [UnmanagedCallersOnly] set => throw null;
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(7, 10),
-                // (8,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (8,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //         [UnmanagedCallersOnly] get => throw null;
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(8, 10)
             );
@@ -9014,7 +9059,7 @@ static void M(C c1, C c2)
 ", UnmanagedCallersOnlyAttribute });
 
             comp.VerifyDiagnostics(
-                // (5,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (5,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //     [UnmanagedCallersOnly]
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(5, 6)
             );
@@ -9076,7 +9121,7 @@ static void M(C c)
 ", UnmanagedCallersOnlyAttribute });
 
             comp.VerifyDiagnostics(
-                // (5,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (5,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //     [UnmanagedCallersOnly]
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(5, 6)
             );
@@ -9214,7 +9259,7 @@ public static class CExt
 ", UnmanagedCallersOnlyAttribute });
 
             comp.VerifyDiagnostics(
-                // (12,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (12,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //     [UnmanagedCallersOnly]
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(12, 6)
             );
@@ -9246,7 +9291,7 @@ public static class CExt
 ", UnmanagedCallersOnlyAttribute });
 
             comp.VerifyDiagnostics(
-                // (14,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (14,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //     [UnmanagedCallersOnly]
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(14, 6)
             );
@@ -9745,7 +9790,7 @@ public UnmanagedCallersOnlyAttribute() { }
                 // (7,10): error CS8893: 'UnmanagedCallersOnlyAttribute' is not a valid calling convention type for 'UnmanagedCallersOnly'.
                 //         [UnmanagedCallersOnly(CallConvs = new[] { typeof(UnmanagedCallersOnlyAttribute) })]
                 Diagnostic(ErrorCode.ERR_InvalidUnmanagedCallersOnlyCallConv, "UnmanagedCallersOnly(CallConvs = new[] { typeof(UnmanagedCallersOnlyAttribute) })").WithArguments("System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute").WithLocation(7, 10),
-                // (7,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (7,10): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //         [UnmanagedCallersOnly(CallConvs = new[] { typeof(UnmanagedCallersOnlyAttribute) })]
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(7, 10)
             );
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenInterfaceImplementation.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenInterfaceImplementation.cs
index eaff9bc547594..9c5906d8aa7b5 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenInterfaceImplementation.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenInterfaceImplementation.cs
@@ -771,7 +771,7 @@ public static void Main()
                     Signature("Derived", "set_Property", ".method public hidebysig specialname instance System.Void set_Property(System.String value) cil managed"),
                 // Stubs in Derived3 "call" corresponding members in Derived above
                 Signature("Derived3", "Interface.Method", ".method private hidebysig newslot virtual final instance System.Void Interface.Method() cil managed"),
-                    Signature("Derived3", "Interface.set_Property", ".method private hidebysig newslot specialname virtual final instance System.Void Interface.set_Property(System.String value) cil managed"),
+                    Signature("Derived3", "Interface.set_Property", ".method private hidebysig newslot virtual final instance System.Void Interface.set_Property(System.String value) cil managed"),
                 });
 
             comp.VerifyDiagnostics(); // No errors
@@ -869,7 +869,7 @@ public static void Main()
                     Signature("Derived", "set_Property", ".method public hidebysig specialname instance System.Void set_Property(System.String value) cil managed"),
                 // Stubs in Derived3 "call" corresponding members in Derived above
                 Signature("Derived3", "Interface.Method", ".method private hidebysig newslot virtual final instance System.Void Interface.Method() cil managed"),
-                    Signature("Derived3", "Interface.set_Property", ".method private hidebysig newslot specialname virtual final instance System.Void Interface.set_Property(System.String value) cil managed")
+                    Signature("Derived3", "Interface.set_Property", ".method private hidebysig newslot virtual final instance System.Void Interface.set_Property(System.String value) cil managed")
                 });
 
             comp.VerifyDiagnostics(); // No errors
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleEqualityTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleEqualityTests.cs
index 5c099ac55b72b..89ee7957084a1 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleEqualityTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleEqualityTests.cs
@@ -1353,17 +1353,27 @@ static void Main()
         System.Console.Write((null, () => 2) == default);
     }
 }";
-            var comp = CreateCompilation(source);
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
                 // (6,30): error CS0034: Operator '==' is ambiguous on operands of type '<null>' and 'default'
                 //         System.Console.Write((null, () => 1) == (default, default));
                 Diagnostic(ErrorCode.ERR_AmbigBinaryOps, "(null, () => 1) == (default, default)").WithArguments("==", "<null>", "default").WithLocation(6, 30),
-                // (6,37): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (6,37): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         System.Console.Write((null, () => 1) == (default, default));
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => 1").WithArguments("inferred delegate type").WithLocation(6, 37),
-                // (6,37): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "() => 1").WithArguments("inferred delegate type", "10.0").WithLocation(6, 37),
+                // (6,37): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         System.Console.Write((null, () => 1) == (default, default));
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => 1").WithArguments("inferred delegate type").WithLocation(6, 37),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "() => 1").WithArguments("inferred delegate type", "10.0").WithLocation(6, 37),
+                // (7,30): error CS0034: Operator '==' is ambiguous on operands of type '(<null>, lambda expression)' and 'default'
+                //         System.Console.Write((null, () => 2) == default);
+                Diagnostic(ErrorCode.ERR_AmbigBinaryOps, "(null, () => 2) == default").WithArguments("==", "(<null>, lambda expression)", "default").WithLocation(7, 30)
+                );
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (6,30): error CS0034: Operator '==' is ambiguous on operands of type '<null>' and 'default'
+                //         System.Console.Write((null, () => 1) == (default, default));
+                Diagnostic(ErrorCode.ERR_AmbigBinaryOps, "(null, () => 1) == (default, default)").WithArguments("==", "<null>", "default").WithLocation(6, 30),
                 // (7,30): error CS0034: Operator '==' is ambiguous on operands of type '(<null>, lambda expression)' and 'default'
                 //         System.Console.Write((null, () => 2) == default);
                 Diagnostic(ErrorCode.ERR_AmbigBinaryOps, "(null, () => 2) == default").WithArguments("==", "(<null>, lambda expression)", "default").WithLocation(7, 30)
@@ -1662,30 +1672,30 @@ static void Main()
 }";
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (6,65): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (6,65): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         System.Console.Write((null, null, null, null) == (null, x => x, Main, (int i) => { int j = 0; return i + j; }));
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x => x").WithArguments("inferred delegate type").WithLocation(6, 65),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "x => x").WithArguments("inferred delegate type", "10.0").WithLocation(6, 65),
                 // (6,65): error CS8917: The delegate type could not be inferred.
                 //         System.Console.Write((null, null, null, null) == (null, x => x, Main, (int i) => { int j = 0; return i + j; }));
                 Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(6, 65),
-                // (6,65): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (6,65): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         System.Console.Write((null, null, null, null) == (null, x => x, Main, (int i) => { int j = 0; return i + j; }));
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x => x").WithArguments("inferred delegate type").WithLocation(6, 65),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "x => x").WithArguments("inferred delegate type", "10.0").WithLocation(6, 65),
                 // (6,65): error CS8917: The delegate type could not be inferred.
                 //         System.Console.Write((null, null, null, null) == (null, x => x, Main, (int i) => { int j = 0; return i + j; }));
                 Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(6, 65),
-                // (6,73): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (6,73): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         System.Console.Write((null, null, null, null) == (null, x => x, Main, (int i) => { int j = 0; return i + j; }));
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "Main").WithArguments("inferred delegate type").WithLocation(6, 73),
-                // (6,73): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "Main").WithArguments("inferred delegate type", "10.0").WithLocation(6, 73),
+                // (6,73): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         System.Console.Write((null, null, null, null) == (null, x => x, Main, (int i) => { int j = 0; return i + j; }));
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "Main").WithArguments("inferred delegate type").WithLocation(6, 73),
-                // (6,79): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "Main").WithArguments("inferred delegate type", "10.0").WithLocation(6, 73),
+                // (6,79): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         System.Console.Write((null, null, null, null) == (null, x => x, Main, (int i) => { int j = 0; return i + j; }));
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(int i) => { int j = 0; return i + j; }").WithArguments("inferred delegate type").WithLocation(6, 79),
-                // (6,79): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(int i) => { int j = 0; return i + j; }").WithArguments("inferred delegate type", "10.0").WithLocation(6, 79),
+                // (6,79): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         System.Console.Write((null, null, null, null) == (null, x => x, Main, (int i) => { int j = 0; return i + j; }));
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "(int i) => { int j = 0; return i + j; }").WithArguments("inferred delegate type").WithLocation(6, 79));
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(int i) => { int j = 0; return i + j; }").WithArguments("inferred delegate type", "10.0").WithLocation(6, 79));
             verify(comp);
 
             comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
@@ -2017,9 +2027,6 @@ public void M()
                 // (6,13): error CS0815: Cannot assign (<null>, <null>) to an implicitly-typed variable
                 //         var t = (null, null);
                 Diagnostic(ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, "t = (null, null)").WithArguments("(<null>, <null>)").WithLocation(6, 13),
-                // (7,22): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                //         if (null == (() => {}) ) {}
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => {}").WithArguments("inferred delegate type").WithLocation(7, 22),
                 // (8,13): error CS0019: Operator '==' cannot be applied to operands of type 'string' and 'int'
                 //         if ("" == 1) {}
                 Diagnostic(ErrorCode.ERR_BadBinaryOps, @""""" == 1").WithArguments("==", "string", "int").WithLocation(8, 13)
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index fe1000a62b48a..a06040ba8b4c2 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -2419,7 +2419,7 @@ public class Class1 : CppCli.CppBase2, CppCli.CppInterface1
 
             var class1TypeDef = (Cci.ITypeDefinition)class1.GetCciAdapter();
 
-            var symbolSynthesized = class1.GetSynthesizedExplicitImplementations(CancellationToken.None);
+            var symbolSynthesized = class1.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods;
             var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var cciExplicit = class1TypeDef.GetExplicitImplementationOverrides(context);
             var cciMethods = class1TypeDef.GetMethods(context).Where(m => ((MethodSymbol)m.GetInternalSymbol()).MethodKind != MethodKind.Constructor);
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueClosureTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueClosureTests.cs
index 003401a3770ab..16def4e4ea2af 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueClosureTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueClosureTests.cs
@@ -309,7 +309,7 @@ void F()
             CheckEncLogDefinitions(reader1,
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -362,7 +362,7 @@ void F()
             CheckEncLogDefinitions(reader1,
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
             var testData0 = new CompilationTestData();
             var bytes0 = compilation0.EmitToArray(testData: testData0);
@@ -477,7 +477,7 @@ void F<T>()
                 Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -532,7 +532,7 @@ int F(int a)
                 Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -586,7 +586,7 @@ int F(int a)
                 Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -786,7 +786,7 @@ int F(int a)
                 Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -1076,8 +1076,8 @@ void F()
                 Row(18, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(19, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(20, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(17, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(18, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(16, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -1153,7 +1153,7 @@ void F()
                 Row(10, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(15, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -1240,9 +1240,9 @@ public void F()
                 Row(8, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(10, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(12, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -1322,7 +1322,7 @@ public void F()
                 Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(10, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -1399,7 +1399,7 @@ public void F()
                 Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -4002,7 +4002,7 @@ .maxstack  2
                 Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -4087,7 +4087,7 @@ .maxstack  2
                 Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -4160,7 +4160,7 @@ .maxstack  2
             CheckEncLogDefinitions(reader1,
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.cs
index 7dae6013bdcab..77d26eb3af244 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.cs
@@ -536,9 +536,13 @@ static IEnumerable<int> F()
 
                 using (var md1 = diff1.GetMetadata())
                 {
+                    CheckAttributes(md1.Reader,
+                        new CustomAttributeRow(Handle(0, TableIndex.MethodDef), Handle(0, TableIndex.MemberRef)));  // row id 0 == delete
+
                     CheckEncLogDefinitions(md1.Reader,
                         Row(3, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
-                        Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Delete IteratorStateMachineAttribute
                 }
             }
         }
@@ -583,9 +587,15 @@ static Task<int> F()
 
                 using (var md1 = diff1.GetMetadata())
                 {
+                    CheckAttributes(md1.Reader,
+                        new CustomAttributeRow(Handle(0, TableIndex.MethodDef), Handle(0, TableIndex.MemberRef)),  // row id 0 == delete
+                        new CustomAttributeRow(Handle(0, TableIndex.MethodDef), Handle(0, TableIndex.MemberRef))); // row id 0 == delete
+
                     CheckEncLogDefinitions(md1.Reader,
                         Row(3, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
-                        Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),  // Delete AsyncStateMachineAttribute
+                        Row(2, TableIndex.CustomAttribute, EditAndContinueOperation.Default));  // Delete DebuggerStepThroughAttribute
                 }
             }
         }
@@ -674,12 +684,12 @@ static async Task<int> F(int a)
                         Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(16, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(17, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(18, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(19, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(20, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(21, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(2, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(8, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
                 }
             }
         }
@@ -738,8 +748,8 @@ static IEnumerable<int> F()
                         Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
                     diff1.VerifyIL("C.<F>d__0.System.Collections.IEnumerator.MoveNext", @"
 {
@@ -875,8 +885,8 @@ static async Task<int> F()
                         Row(4, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                         Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(8, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(2, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
                     diff1.VerifyIL("C.<F>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext", @"
 {
@@ -1146,8 +1156,8 @@ static IEnumerable<int> F(int p)
                         Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
                     diff1.VerifyIL("C.<F>d__0.System.Collections.IEnumerator.MoveNext", @"
 {
@@ -1250,8 +1260,8 @@ static IEnumerable<int> F(int p)
                         Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
                     diff1.VerifyIL("C.<F>d__0.System.Collections.IEnumerator.MoveNext", @"
 {
@@ -1361,8 +1371,8 @@ static IEnumerable<int> F(int p)
                         Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
                     diff1.VerifyIL("C.<F>d__0.System.Collections.IEnumerator.MoveNext", @"
 {
@@ -1469,8 +1479,8 @@ static IEnumerable<int> F()
                         Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
                     diff1.VerifyIL("C.<F>d__0.System.Collections.IEnumerator.MoveNext", @"
 {
@@ -1586,8 +1596,8 @@ static IEnumerable<int> F()
                         Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                        Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
                     diff1.VerifyIL("C.<F>d__0.System.Collections.IEnumerator.MoveNext", @"
 {
@@ -1879,10 +1889,10 @@ static async Task<int> H() // updated
                 Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(16, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(17, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(18, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(19, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(2, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
             diff1.VerifyIL("C.<F>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext", @"
 {
@@ -1990,8 +2000,8 @@ .locals init (int V_0,
                 Row(18, TableIndex.Field, EditAndContinueOperation.Default),
                 Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(20, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(21, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(1, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(2, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
             diff2.VerifyIL("C.<F>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext", @"
 {
@@ -2103,10 +2113,10 @@ .locals init (int V_0,
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(22, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(23, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(24, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(25, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(8, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
@@ -2626,10 +2636,10 @@ static async Task<int> H() // updated
                 Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(16, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(17, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(18, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(19, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(8, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
             // Note that the new awaiter is allocated slot <>u__3 since <>u__1 and <>u__2 are taken.
             diff1.VerifyIL("C.<F>d__3.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext", @"
@@ -2766,8 +2776,8 @@ .locals init (int V_0,
                 Row(12, TableIndex.Field, EditAndContinueOperation.Default),
                 Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(20, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(21, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
 
             // Note that the new awaiters are allocated slots <>u__4, <>u__5.
             diff2.VerifyIL("C.<F>d__3.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext", @"
@@ -2910,10 +2920,10 @@ .locals init (int V_0,
                 Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(15, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(22, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(23, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(24, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(25, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
+                Row(8, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(12, TableIndex.CustomAttribute, EditAndContinueOperation.Default));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
index 0652a0d96bc13..3a6e5142eb10f 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
@@ -359,6 +359,692 @@ static void Main() { }
                 Handle(2, TableIndex.AssemblyRef));
         }
 
+        [Fact]
+        public void ModifyMethod_WithAttributes1()
+        {
+            var source0 =
+@"class C
+{
+    static void Main() { }
+    [System.ComponentModel.Description(""The F method"")]
+    static string F() { return null; }
+}";
+            var source1 =
+@"class C
+{
+    static void Main() { }
+    [System.ComponentModel.Description(""The F method"")]
+    static string F() { return string.Empty; }
+}";
+            var source2 =
+@"[System.ComponentModel.Browsable(false)]
+class C
+{
+    static void Main() { }
+    [System.ComponentModel.Description(""The F method""), System.ComponentModel.Category(""Methods"")]
+    static string F() { return string.Empty; }
+}";
+            var source3 =
+@"[System.ComponentModel.Browsable(false)]
+class C
+{
+    static void Main() { }
+    [System.ComponentModel.Browsable(false), System.ComponentModel.Description(""The F method""), System.ComponentModel.Category(""Methods"")]
+    static string F() { return string.Empty; }
+}";
+
+            var compilation0 = CreateCompilation(source0, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetStandard20);
+            var compilation1 = compilation0.WithSource(source1);
+            var compilation2 = compilation1.WithSource(source2);
+            var compilation3 = compilation2.WithSource(source3);
+
+            var method0 = compilation0.GetMember<MethodSymbol>("C.F");
+
+            // Verify full metadata contains expected rows.
+            var bytes0 = compilation0.EmitToArray();
+            using var md0 = ModuleMetadata.CreateFromImage(bytes0);
+            var reader0 = md0.MetadataReader;
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C");
+            CheckNames(reader0, reader0.GetMethodDefNames(), "Main", "F", ".ctor");
+            CheckNames(reader0, reader0.GetMemberRefNames(), /*CompilationRelaxationsAttribute.*/".ctor", /*RuntimeCompatibilityAttribute.*/".ctor", /*Object.*/".ctor", /*DebuggableAttribute*/".ctor", /*DescriptionAttribute*/".ctor");
+
+            Assert.Equal(4, reader0.CustomAttributes.Count);
+
+            var generation0 = EmitBaseline.CreateInitialBaseline(
+                md0,
+                EmptyLocalsProvider);
+            var method1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1)));
+
+            // Verify delta metadata contains expected rows.
+            using var md1 = diff1.GetMetadata();
+            var reader1 = md1.Reader;
+            var readers = new[] { reader0, reader1 };
+
+            EncValidation.VerifyModuleMvid(1, reader0, reader1);
+
+            CheckNames(readers, reader1.GetTypeDefNames());
+            CheckNames(readers, reader1.GetMethodDefNames(), "F");
+            CheckNames(readers, reader1.GetMemberRefNames(), /*DescriptionAttribute*/".ctor", /*String.*/"Empty");
+
+            Assert.Equal(1, reader1.CustomAttributes.Count);
+
+            CheckEncLog(reader1,
+                Row(2, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(6, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(7, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(7, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(8, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(9, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Row 4, so updating existing CustomAttribute
+
+            CheckEncMap(reader1,
+                Handle(7, TableIndex.TypeRef),
+                Handle(8, TableIndex.TypeRef),
+                Handle(9, TableIndex.TypeRef),
+                Handle(2, TableIndex.MethodDef),
+                Handle(6, TableIndex.MemberRef),
+                Handle(7, TableIndex.MemberRef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(2, TableIndex.StandAloneSig),
+                Handle(2, TableIndex.AssemblyRef));
+
+            var method2 = compilation2.GetMember<MethodSymbol>("C.F");
+            var diff2 = compilation2.EmitDifference(
+                diff1.NextGeneration,
+                ImmutableArray.Create(
+                    SemanticEdit.Create(SemanticEditKind.Update, compilation1.GetMember("C"), compilation2.GetMember("C")),
+                    SemanticEdit.Create(SemanticEditKind.Update, method1, method2)));
+
+            // Verify delta metadata contains expected rows.
+            using var md2 = diff2.GetMetadata();
+            var reader2 = md2.Reader;
+            readers = new[] { reader0, reader1, reader2 };
+
+            CheckNames(readers, reader2.GetTypeDefNames(), "C");
+            CheckNames(readers, reader2.GetMethodDefNames(), "F");
+            CheckNames(readers, reader2.GetMemberRefNames(), /*DescriptionAttribute*/".ctor", /*BrowsableAttribute*/".ctor", /*CategoryAttribute*/".ctor", /*String.*/"Empty");
+
+            Assert.Equal(3, reader2.CustomAttributes.Count);
+
+            CheckEncLog(reader2,
+                Row(3, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(8, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(9, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(10, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(11, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(10, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(11, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(12, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(13, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(14, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(3, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.TypeDef, EditAndContinueOperation.Default),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),  // Row 4, updating the existing custom attribute
+                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),  // Row 5, adding a new CustomAttribute
+                Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Row 6 adding a new CustomAttribute
+
+            CheckEncMap(reader2,
+                Handle(10, TableIndex.TypeRef),
+                Handle(11, TableIndex.TypeRef),
+                Handle(12, TableIndex.TypeRef),
+                Handle(13, TableIndex.TypeRef),
+                Handle(14, TableIndex.TypeRef),
+                Handle(2, TableIndex.TypeDef),
+                Handle(2, TableIndex.MethodDef),
+                Handle(8, TableIndex.MemberRef),
+                Handle(9, TableIndex.MemberRef),
+                Handle(10, TableIndex.MemberRef),
+                Handle(11, TableIndex.MemberRef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(5, TableIndex.CustomAttribute),
+                Handle(6, TableIndex.CustomAttribute),
+                Handle(3, TableIndex.StandAloneSig),
+                Handle(3, TableIndex.AssemblyRef));
+
+            var method3 = compilation3.GetMember<MethodSymbol>("C.F");
+            var diff3 = compilation3.EmitDifference(
+                diff2.NextGeneration,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method2, method3)));
+
+            // Verify delta metadata contains expected rows.
+            using var md3 = diff3.GetMetadata();
+            var reader3 = md3.Reader;
+            readers = new[] { reader0, reader1, reader2, reader3 };
+
+            CheckNames(readers, reader3.GetTypeDefNames());
+            CheckNames(readers, reader3.GetMethodDefNames(), "F");
+            CheckNames(readers, reader3.GetMemberRefNames(), /*BrowsableAttribute*/".ctor", /*DescriptionAttribute*/".ctor", /*CategoryAttribute*/".ctor", /*String.*/"Empty");
+
+            CheckEncLog(reader3,
+                Row(4, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(12, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(13, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(14, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(15, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(15, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(16, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(17, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(18, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(19, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default), // Row 4, updating the existing custom attribute
+                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default), // Row 5, updating a row that was new in Generation 2
+                Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Row 7, adding a new CustomAttribute, and skipping row 6 which is not for the method being emitted
+
+            CheckEncMap(reader3,
+                Handle(15, TableIndex.TypeRef),
+                Handle(16, TableIndex.TypeRef),
+                Handle(17, TableIndex.TypeRef),
+                Handle(18, TableIndex.TypeRef),
+                Handle(19, TableIndex.TypeRef),
+                Handle(2, TableIndex.MethodDef),
+                Handle(12, TableIndex.MemberRef),
+                Handle(13, TableIndex.MemberRef),
+                Handle(14, TableIndex.MemberRef),
+                Handle(15, TableIndex.MemberRef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(5, TableIndex.CustomAttribute),
+                Handle(7, TableIndex.CustomAttribute),
+                Handle(4, TableIndex.StandAloneSig),
+                Handle(4, TableIndex.AssemblyRef));
+        }
+
+        [Fact]
+        public void ModifyMethod_WithAttributes2()
+        {
+            var source0 =
+@"[System.ComponentModel.Browsable(false)]
+class C
+{
+    static void Main() { }
+    [System.ComponentModel.Description(""The F method"")]
+    static string F() { return null; }
+}
+[System.ComponentModel.Browsable(false)]
+class D
+{
+    [System.ComponentModel.Description(""A"")]
+    static string A() { return null; }
+}
+";
+            var source1 =
+@"
+[System.ComponentModel.Browsable(false)]
+class C
+{
+    static void Main() { }
+    [System.ComponentModel.Description(""The F method""), System.ComponentModel.Browsable(false), System.ComponentModel.Category(""Methods"")]
+    static string F() { return null; }
+}
+[System.ComponentModel.Browsable(false)]
+class D
+{
+    [System.ComponentModel.Description(""A""), System.ComponentModel.Category(""Methods"")]
+    static string A() { return null; }
+}
+";
+
+            var compilation0 = CreateCompilation(source0, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetStandard20);
+            var compilation1 = compilation0.WithSource(source1);
+
+            var method0_1 = compilation0.GetMember<MethodSymbol>("C.F");
+            var method0_2 = compilation0.GetMember<MethodSymbol>("D.A");
+
+            // Verify full metadata contains expected rows.
+            var bytes0 = compilation0.EmitToArray();
+            using var md0 = ModuleMetadata.CreateFromImage(bytes0);
+            var reader0 = md0.MetadataReader;
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C", "D");
+            CheckNames(reader0, reader0.GetMethodDefNames(), "Main", "F", ".ctor", "A", ".ctor");
+            CheckNames(reader0, reader0.GetMemberRefNames(), /*CompilationRelaxationsAttribute.*/".ctor", /*RuntimeCompatibilityAttribute.*/".ctor", /*Object.*/".ctor", /*DebuggableAttribute*/".ctor", /*DescriptionAttribute*/".ctor", /*BrowsableAttribute*/".ctor");
+
+            CheckAttributes(reader0,
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(1, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(2, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(3, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(2, TableIndex.MethodDef), Handle(5, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(2, TableIndex.TypeDef), Handle(4, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(3, TableIndex.TypeDef), Handle(4, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(4, TableIndex.MethodDef), Handle(5, TableIndex.MemberRef)));
+
+            var generation0 = EmitBaseline.CreateInitialBaseline(
+                md0,
+                EmptyLocalsProvider);
+            var method1_1 = compilation1.GetMember<MethodSymbol>("C.F");
+            var method1_2 = compilation1.GetMember<MethodSymbol>("D.A");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(
+                    SemanticEdit.Create(SemanticEditKind.Update, method0_1, method1_1),
+                    SemanticEdit.Create(SemanticEditKind.Update, method0_2, method1_2)));
+
+            // Verify delta metadata contains expected rows.
+            using var md1 = diff1.GetMetadata();
+            var reader1 = md1.Reader;
+            var readers = new[] { reader0, reader1 };
+
+            EncValidation.VerifyModuleMvid(1, reader0, reader1);
+
+            CheckNames(readers, reader1.GetTypeDefNames());
+            CheckNames(readers, reader1.GetMethodDefNames(), "F", "A");
+            CheckNames(readers, reader1.GetMemberRefNames(), /*BrowsableAttribute*/".ctor", /*CategoryAttribute*/".ctor", /*DescriptionAttribute*/".ctor");
+
+            CheckAttributes(reader1,
+                new CustomAttributeRow(Handle(2, TableIndex.MethodDef), Handle(8, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(2, TableIndex.MethodDef), Handle(7, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(2, TableIndex.MethodDef), Handle(9, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(4, TableIndex.MethodDef), Handle(8, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(4, TableIndex.MethodDef), Handle(9, TableIndex.MemberRef)));
+
+            CheckEncLog(reader1,
+                Row(2, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(7, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(8, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(9, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(8, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(9, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(10, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(11, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),    // update existing row
+                Row(8, TableIndex.CustomAttribute, EditAndContinueOperation.Default),    // add new row
+                Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),    // add new row
+                Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),    // update existing row
+                Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default));  // add new row
+
+            CheckEncMap(reader1,
+                Handle(8, TableIndex.TypeRef),
+                Handle(9, TableIndex.TypeRef),
+                Handle(10, TableIndex.TypeRef),
+                Handle(11, TableIndex.TypeRef),
+                Handle(2, TableIndex.MethodDef),
+                Handle(4, TableIndex.MethodDef),
+                Handle(7, TableIndex.MemberRef),
+                Handle(8, TableIndex.MemberRef),
+                Handle(9, TableIndex.MemberRef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(7, TableIndex.CustomAttribute),
+                Handle(8, TableIndex.CustomAttribute),
+                Handle(9, TableIndex.CustomAttribute),
+                Handle(10, TableIndex.CustomAttribute),
+                Handle(2, TableIndex.StandAloneSig),
+                Handle(2, TableIndex.AssemblyRef));
+        }
+
+        [Fact]
+        public void ModifyMethod_DeleteAttributes1()
+        {
+            var source0 =
+@"class C
+{
+    static void Main() { }
+    [System.ComponentModel.Description(""The F method"")]
+    static string F() { return null; }
+}";
+            var source1 =
+@"class C
+{
+    static void Main() { }
+    static string F() { return string.Empty; }
+}";
+            var source2 =
+@"class C
+{
+    static void Main() { }
+    [System.ComponentModel.Description(""The F method"")]
+    static string F() { return string.Empty; }
+}";
+
+            var compilation0 = CreateCompilation(source0, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetStandard20);
+            var compilation1 = compilation0.WithSource(source1);
+            var compilation2 = compilation1.WithSource(source2);
+
+            var method0 = compilation0.GetMember<MethodSymbol>("C.F");
+
+            // Verify full metadata contains expected rows.
+            var bytes0 = compilation0.EmitToArray();
+            using var md0 = ModuleMetadata.CreateFromImage(bytes0);
+            var reader0 = md0.MetadataReader;
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C");
+            CheckNames(reader0, reader0.GetMethodDefNames(), "Main", "F", ".ctor");
+            CheckNames(reader0, reader0.GetMemberRefNames(), /*CompilationRelaxationsAttribute.*/".ctor", /*RuntimeCompatibilityAttribute.*/".ctor", /*Object.*/".ctor", /*DebuggableAttribute*/".ctor", /*DescriptionAttribute*/".ctor");
+
+            CheckAttributes(reader0,
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(1, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(2, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(3, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(2, TableIndex.MethodDef), Handle(4, TableIndex.MemberRef)));
+
+            var generation0 = EmitBaseline.CreateInitialBaseline(
+                md0,
+                EmptyLocalsProvider);
+            var method1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1)));
+
+            // Verify delta metadata contains expected rows.
+            using var md1 = diff1.GetMetadata();
+            var reader1 = md1.Reader;
+            var readers = new[] { reader0, reader1 };
+
+            EncValidation.VerifyModuleMvid(1, reader0, reader1);
+
+            CheckNames(readers, reader1.GetTypeDefNames());
+            CheckNames(readers, reader1.GetMethodDefNames(), "F");
+            CheckNames(readers, reader1.GetMemberRefNames(), /*String.*/"Empty");
+
+            CheckAttributes(reader1,
+                new CustomAttributeRow(Handle(0, TableIndex.MethodDef), Handle(0, TableIndex.MemberRef)));  // Parent row id is 0, signifying a delete
+
+            CheckEncLog(reader1,
+                Row(2, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(6, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(7, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(8, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Row 4, so updating existing CustomAttribute
+
+            CheckEncMap(reader1,
+                Handle(7, TableIndex.TypeRef),
+                Handle(8, TableIndex.TypeRef),
+                Handle(2, TableIndex.MethodDef),
+                Handle(6, TableIndex.MemberRef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(2, TableIndex.StandAloneSig),
+                Handle(2, TableIndex.AssemblyRef));
+
+            var method2 = compilation2.GetMember<MethodSymbol>("C.F");
+            var diff2 = compilation2.EmitDifference(
+                diff1.NextGeneration,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2)));
+
+            // Verify delta metadata contains expected rows.
+            using var md2 = diff2.GetMetadata();
+            var reader2 = md2.Reader;
+            readers = new[] { reader0, reader1, reader2 };
+
+            EncValidation.VerifyModuleMvid(2, reader1, reader2);
+
+            CheckNames(readers, reader2.GetTypeDefNames());
+            CheckNames(readers, reader2.GetMethodDefNames(), "F");
+            CheckNames(readers, reader2.GetMemberRefNames(), /*DescriptionAttribute*/".ctor", /*String.*/"Empty");
+
+            CheckAttributes(reader2,
+                new CustomAttributeRow(Handle(2, TableIndex.MethodDef), Handle(7, TableIndex.MemberRef)));
+
+            CheckEncLog(reader2,
+                Row(3, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(7, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(8, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(9, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(10, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(11, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(3, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Row 4, updating the original row back to a real one
+
+            CheckEncMap(reader2,
+                Handle(9, TableIndex.TypeRef),
+                Handle(10, TableIndex.TypeRef),
+                Handle(11, TableIndex.TypeRef),
+                Handle(2, TableIndex.MethodDef),
+                Handle(7, TableIndex.MemberRef),
+                Handle(8, TableIndex.MemberRef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(3, TableIndex.StandAloneSig),
+                Handle(3, TableIndex.AssemblyRef));
+        }
+
+        [Fact]
+        public void ModifyMethod_DeleteAttributes2()
+        {
+            var source0 =
+@"class C
+{
+    static void Main() { }
+    static string F() { return null; }
+}";
+            var source1 =
+@"class C
+{
+    static void Main() { }
+    [System.ComponentModel.Description(""The F method"")]
+    static string F() { return string.Empty; }
+}";
+            var source2 = source0; // Remove the attribute we just added
+            var source3 = source1; // Add the attribute back again
+
+            var compilation0 = CreateCompilation(source0, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetStandard20);
+            var compilation1 = compilation0.WithSource(source1);
+            var compilation2 = compilation1.WithSource(source2);
+            var compilation3 = compilation1.WithSource(source3);
+
+            var method0 = compilation0.GetMember<MethodSymbol>("C.F");
+
+            // Verify full metadata contains expected rows.
+            var bytes0 = compilation0.EmitToArray();
+            using var md0 = ModuleMetadata.CreateFromImage(bytes0);
+            var reader0 = md0.MetadataReader;
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C");
+            CheckNames(reader0, reader0.GetMethodDefNames(), "Main", "F", ".ctor");
+            CheckNames(reader0, reader0.GetMemberRefNames(), /*CompilationRelaxationsAttribute.*/".ctor", /*RuntimeCompatibilityAttribute.*/".ctor", /*Object.*/".ctor", /*DebuggableAttribute*/".ctor");
+
+            CheckAttributes(reader0,
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(1, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(2, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(3, TableIndex.MemberRef)));
+
+            var generation0 = EmitBaseline.CreateInitialBaseline(
+                md0,
+                EmptyLocalsProvider);
+            var method1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1)));
+
+            // Verify delta metadata contains expected rows.
+            using var md1 = diff1.GetMetadata();
+            var reader1 = md1.Reader;
+            var readers = new[] { reader0, reader1 };
+
+            EncValidation.VerifyModuleMvid(1, reader0, reader1);
+
+            CheckNames(readers, reader1.GetTypeDefNames());
+            CheckNames(readers, reader1.GetMethodDefNames(), "F");
+            CheckNames(readers, reader1.GetMemberRefNames(), /*DescriptionAttribute*/".ctor", /*String.*/"Empty");
+
+            CheckAttributes(reader1,
+                new CustomAttributeRow(Handle(2, TableIndex.MethodDef), Handle(5, TableIndex.MemberRef)));
+
+            CheckEncLog(reader1,
+                Row(2, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(5, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(6, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(6, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(7, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(8, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Row 4, so adding a new CustomAttribute
+
+            CheckEncMap(reader1,
+                Handle(6, TableIndex.TypeRef),
+                Handle(7, TableIndex.TypeRef),
+                Handle(8, TableIndex.TypeRef),
+                Handle(2, TableIndex.MethodDef),
+                Handle(5, TableIndex.MemberRef),
+                Handle(6, TableIndex.MemberRef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(2, TableIndex.StandAloneSig),
+                Handle(2, TableIndex.AssemblyRef));
+
+            var method2 = compilation2.GetMember<MethodSymbol>("C.F");
+            var diff2 = compilation2.EmitDifference(
+                diff1.NextGeneration,
+                ImmutableArray.Create(
+                    SemanticEdit.Create(SemanticEditKind.Update, method1, method2)));
+
+            // Verify delta metadata contains expected rows.
+            using var md2 = diff2.GetMetadata();
+            var reader2 = md2.Reader;
+            readers = new[] { reader0, reader1, reader2 };
+
+            CheckNames(readers, reader2.GetTypeDefNames());
+            CheckNames(readers, reader2.GetMethodDefNames(), "F");
+            CheckNames(readers, reader2.GetMemberRefNames());
+
+            CheckAttributes(reader2,
+                new CustomAttributeRow(Handle(0, TableIndex.MethodDef), Handle(0, TableIndex.MemberRef)));  // 0, delete
+
+            CheckEncLog(reader2,
+                Row(3, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(9, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(3, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Row 4, so updating existing CustomAttribute
+
+            CheckEncMap(reader2,
+                Handle(9, TableIndex.TypeRef),
+                Handle(2, TableIndex.MethodDef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(3, TableIndex.StandAloneSig),
+                Handle(3, TableIndex.AssemblyRef));
+
+            var method3 = compilation3.GetMember<MethodSymbol>("C.F");
+            var diff3 = compilation3.EmitDifference(
+                diff2.NextGeneration,
+                ImmutableArray.Create(
+                    SemanticEdit.Create(SemanticEditKind.Update, method2, method3)));
+
+            // Verify delta metadata contains expected rows.
+            using var md3 = diff3.GetMetadata();
+            var reader3 = md3.Reader;
+            readers = new[] { reader0, reader1, reader2, reader3 };
+
+            CheckNames(readers, reader3.GetTypeDefNames());
+            CheckNames(readers, reader3.GetMethodDefNames(), "F");
+            CheckNames(readers, reader3.GetMemberRefNames(), /*DescriptionAttribute*/".ctor", /*String.*/"Empty");
+
+            CheckAttributes(reader3,
+                new CustomAttributeRow(Handle(2, TableIndex.MethodDef), Handle(7, TableIndex.MemberRef)));
+
+            CheckEncLog(reader3,
+                Row(4, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(7, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(8, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(10, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(11, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(12, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Row 4, update the previously deleted row
+
+            CheckEncMap(reader3,
+                Handle(10, TableIndex.TypeRef),
+                Handle(11, TableIndex.TypeRef),
+                Handle(12, TableIndex.TypeRef),
+                Handle(2, TableIndex.MethodDef),
+                Handle(7, TableIndex.MemberRef),
+                Handle(8, TableIndex.MemberRef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(4, TableIndex.StandAloneSig),
+                Handle(4, TableIndex.AssemblyRef));
+        }
+
+        [Fact]
+        public void AddMethod_WithAttributes()
+        {
+            var source0 =
+@"class C
+{
+    static void Main() { }
+}";
+            var source1 =
+@"class C
+{
+    static void Main() { }
+    [System.ComponentModel.Description(""The F method"")]
+    static string F() { return string.Empty; }
+}";
+            var compilation0 = CreateCompilation(source0, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetStandard20);
+            var compilation1 = compilation0.WithSource(source1);
+
+            // Verify full metadata contains expected rows.
+            var bytes0 = compilation0.EmitToArray();
+            using var md0 = ModuleMetadata.CreateFromImage(bytes0);
+            var reader0 = md0.MetadataReader;
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C");
+            CheckNames(reader0, reader0.GetMethodDefNames(), "Main", ".ctor");
+            CheckNames(reader0, reader0.GetMemberRefNames(), /*CompilationRelaxationsAttribute.*/".ctor", /*RuntimeCompatibilityAttribute.*/".ctor", /*Object.*/".ctor", /*DebuggableAttribute*/".ctor");
+
+            Assert.Equal(3, reader0.CustomAttributes.Count);
+
+            var generation0 = EmitBaseline.CreateInitialBaseline(
+                md0,
+                EmptyLocalsProvider);
+            var method1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, method1)));
+
+            // Verify delta metadata contains expected rows.
+            using var md1 = diff1.GetMetadata();
+            var reader1 = md1.Reader;
+            var readers = new[] { reader0, reader1 };
+
+            EncValidation.VerifyModuleMvid(1, reader0, reader1);
+
+            CheckNames(readers, reader1.GetTypeDefNames());
+            CheckNames(readers, reader1.GetMethodDefNames(), "F");
+            CheckNames(readers, reader1.GetMemberRefNames(), /*DescriptionAttribute*/".ctor", /*String.*/"Empty");
+
+            Assert.Equal(1, reader1.CustomAttributes.Count);
+
+            CheckEncLog(reader1,
+                Row(2, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
+                Row(5, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(6, TableIndex.MemberRef, EditAndContinueOperation.Default),
+                Row(6, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(7, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(8, TableIndex.TypeRef, EditAndContinueOperation.Default),
+                Row(1, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(2, TableIndex.TypeDef, EditAndContinueOperation.AddMethod),
+                Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // Row 4, a new attribute
+
+            CheckEncMap(reader1,
+                Handle(6, TableIndex.TypeRef),
+                Handle(7, TableIndex.TypeRef),
+                Handle(8, TableIndex.TypeRef),
+                Handle(3, TableIndex.MethodDef),
+                Handle(5, TableIndex.MemberRef),
+                Handle(6, TableIndex.MemberRef),
+                Handle(4, TableIndex.CustomAttribute),
+                Handle(1, TableIndex.StandAloneSig),
+                Handle(2, TableIndex.AssemblyRef));
+        }
+
         [WorkItem(962219, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/962219")]
         [Fact]
         public void PartialMethod()
@@ -2266,6 +2952,7 @@ [B] static void M2<[A]T>() { }
                 Row(8, TableIndex.Param, EditAndContinueOperation.Default),
                 Row(15, TableIndex.MethodDef, EditAndContinueOperation.AddParameter),
                 Row(9, TableIndex.Param, EditAndContinueOperation.Default),
+                Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
                 Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
                 Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
                 Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
@@ -2274,7 +2961,6 @@ [B] static void M2<[A]T>() { }
                 Row(18, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
                 Row(19, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
                 Row(20, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(21, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
                 Row(4, TableIndex.MethodSemantics, EditAndContinueOperation.Default),
                 Row(5, TableIndex.MethodSemantics, EditAndContinueOperation.Default),
                 Row(6, TableIndex.MethodSemantics, EditAndContinueOperation.Default),
@@ -2300,6 +2986,7 @@ [B] static void M2<[A]T>() { }
                 Handle(13, TableIndex.MemberRef),
                 Handle(14, TableIndex.MemberRef),
                 Handle(15, TableIndex.MemberRef),
+                Handle(7, TableIndex.CustomAttribute),
                 Handle(13, TableIndex.CustomAttribute),
                 Handle(14, TableIndex.CustomAttribute),
                 Handle(15, TableIndex.CustomAttribute),
@@ -2308,7 +2995,6 @@ [B] static void M2<[A]T>() { }
                 Handle(18, TableIndex.CustomAttribute),
                 Handle(19, TableIndex.CustomAttribute),
                 Handle(20, TableIndex.CustomAttribute),
-                Handle(21, TableIndex.CustomAttribute),
                 Handle(3, TableIndex.StandAloneSig),
                 Handle(4, TableIndex.StandAloneSig),
                 Handle(2, TableIndex.Event),
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests.cs
index f6db51c369a28..d2c6d1009d235 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests.cs
@@ -15,7 +15,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     [CompilerTrait(CompilerFeature.IOperation)]
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.RefLocalsReturns)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ArrayCreationAndInitializer.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ArrayCreationAndInitializer.cs
index 84a79c6c42243..c17af1192f6e9 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ArrayCreationAndInitializer.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ArrayCreationAndInitializer.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ArrayCreationAndInitializer : SemanticModelTestBase
     {
         [Fact, WorkItem(17596, "https://github.com/dotnet/roslyn/issues/17596")]
         public void SimpleArrayCreation_PrimitiveType()
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAddressOfOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAddressOfOperation.cs
index a252858009424..0521f233c737c 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAddressOfOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAddressOfOperation.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IAddressOfOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAnonymousFunctionExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAnonymousFunctionExpression.cs
index 12c57016fa39c..7d19e731e1480 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAnonymousFunctionExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAnonymousFunctionExpression.cs
@@ -15,7 +15,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IAnonymousFunctionExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAnonymousObjectCreationOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAnonymousObjectCreationOperation.cs
index 4447e093336bc..3662ef4cf42bc 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAnonymousObjectCreationOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAnonymousObjectCreationOperation.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IAnonymousObjectCreationOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArgument.cs
index 53c2a3b32a45b..5e54b64042ffd 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArgument.cs
@@ -16,7 +16,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IArgument : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArrayElementReferenceExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArrayElementReferenceExpression.cs
index a58d2c62ef14f..00c6b1e0c14c3 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArrayElementReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArrayElementReferenceExpression.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IArrayElementReferenceExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(22006, "https://github.com/dotnet/roslyn/issues/22006")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAwaitExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAwaitExpression.cs
index fc44345496847..b07bacfa088bf 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAwaitExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IAwaitExpression.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IAwaitExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBinaryOperatorExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBinaryOperatorExpression.cs
index ba62251c441f8..9ef49f9dc64f7 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBinaryOperatorExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBinaryOperatorExpression.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IBinaryOperatorExpression : SemanticModelTestBase
     {
         private const string RangeCtorSignature = "System.Range..ctor(System.Index start, System.Index end)";
         private const string RangeStartAtSignature = "System.Range System.Range.StartAt(System.Index start)";
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBlock.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBlock.cs
index f98b61b47a977..ef89d1aee3d5f 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBlock.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBlock.cs
@@ -13,7 +13,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IBlock : SemanticModelTestBase
     {
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBoundDiscardOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBoundDiscardOperation.cs
index 657e2e2197824..f23804706909c 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBoundDiscardOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBoundDiscardOperation.cs
@@ -11,7 +11,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     [CompilerTrait(CompilerFeature.IOperation)]
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IBoundDiscardOperation : SemanticModelTestBase
     {
         [Fact]
         public void DiscardExpression_AsAssignment()
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBranchOperation.Extensions.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBranchOperation.Extensions.cs
index f74d47a116f24..1e22a7f2dfc6f 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBranchOperation.Extensions.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBranchOperation.Extensions.cs
@@ -13,7 +13,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IBranchOperation_Extensions : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [WorkItem(28095, "https://github.com/dotnet/roslyn/issues/28095")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBranchOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBranchOperation.cs
index 74aac99922b51..cca2f42140c70 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBranchOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IBranchOperation.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IBranchOperation : SemanticModelTestBase
     {
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICoalesceAssignmentOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICoalesceAssignmentOperation.cs
index e9c0e5f94e3ed..9f83435bff0fc 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICoalesceAssignmentOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICoalesceAssignmentOperation.cs
@@ -12,7 +12,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     [CompilerTrait(CompilerFeature.IOperation)]
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ICoalesceAssignmentOperation : SemanticModelTestBase
     {
         [Fact]
         public void CoalesceAssignment_SimpleCase()
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICoalesceOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICoalesceOperation.cs
index 1d5cf34d8f0ec..2cd15188bb747 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICoalesceOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICoalesceOperation.cs
@@ -13,7 +13,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ICoalesceOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICompoundAssignmentOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICompoundAssignmentOperation.cs
index 84f063a92d989..2ee2b582adcdc 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICompoundAssignmentOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ICompoundAssignmentOperation.cs
@@ -14,7 +14,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ICompoundAssignmentOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConditionalAccessExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConditionalAccessExpression.cs
index dcf4952a800bb..98d7282b163d8 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConditionalAccessExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConditionalAccessExpression.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IConditionalAccessExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConditionalOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConditionalOperation.cs
index 499b0e409c074..278114c0c9db3 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConditionalOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConditionalOperation.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IConditionalOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConstructorBodyOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConstructorBodyOperation.cs
index 43a2d0c8f52b7..6fe0b6aa2eb9d 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConstructorBodyOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConstructorBodyOperation.cs
@@ -13,7 +13,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     [CompilerTrait(CompilerFeature.IOperation)]
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IConstructorBodyOperation : SemanticModelTestBase
     {
         [Fact]
         public void ConstructorBody_01()
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConversionExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConversionExpression.cs
index 1e1fd613ddac7..e5ba59be5a0b2 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConversionExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IConversionExpression.cs
@@ -15,7 +15,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     // Test list drawn from Microsoft.CodeAnalysis.CSharp.ConversionKind
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IConversionExpression : SemanticModelTestBase
     {
         #region Implicit Conversions
 
@@ -5216,7 +5216,7 @@ public static void Method()
         }
         #endregion
 
-        private class ExpectedSymbolVerifier
+        internal class ExpectedSymbolVerifier
         {
             public static SyntaxNode VariableDeclaratorSelector(SyntaxNode syntaxNode) =>
                 ((VariableDeclaratorSyntax)syntaxNode).Initializer.Value;
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDeclarationExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDeclarationExpression.cs
index 151ff75cc6f96..2bae8b804e10d 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDeclarationExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDeclarationExpression.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IDeclarationExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDeconstructionAssignmentOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDeconstructionAssignmentOperation.cs
index 12cc4e8d7f28e..be6e3283d0b04 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDeconstructionAssignmentOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDeconstructionAssignmentOperation.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IDeconstructionAssignmentOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDefaultValueOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDefaultValueOperation.cs
index bc52b3a4810ba..90554987b83d3 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDefaultValueOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDefaultValueOperation.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IDefaultValueOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDelegateCreationExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDelegateCreationExpression.cs
index 507e522e84da0..4655cfcf35985 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDelegateCreationExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDelegateCreationExpression.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IDelegateCreationExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
@@ -1683,7 +1683,7 @@ void Main()
             };
 
             VerifyOperationTreeAndDiagnosticsForTest<VariableDeclaratorSyntax>(source, expectedOperationTree, expectedDiagnostics,
-                additionalOperationTreeVerifier: new ExpectedSymbolVerifier().Verify);
+                additionalOperationTreeVerifier: new IOperationTests_IConversionExpression.ExpectedSymbolVerifier().Verify);
         }
 
         [CompilerTrait(CompilerFeature.IOperation)]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDiscardOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDiscardOperation.cs
index ca370387c1c7e..6cc4ccbe0d76a 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDiscardOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDiscardOperation.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IDiscardOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicIndexerAccessExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicIndexerAccessExpression.cs
index d0e8cb89bfe42..177a1d26fd053 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicIndexerAccessExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicIndexerAccessExpression.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IDynamicIndexerAccessExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicInvocationExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicInvocationExpression.cs
index 3939be0654cc4..e18b40902fe29 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicInvocationExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicInvocationExpression.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IDynamicInvocationExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicMemberReferenceExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicMemberReferenceExpression.cs
index ebc35c6027dc5..83a7d006920f1 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicMemberReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicMemberReferenceExpression.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IDynamicMemberReferenceExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicObjectCreationExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicObjectCreationExpression.cs
index 3c4acff53ac70..16943cc04a812 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IDynamicObjectCreationExpression.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IDynamicObjectCreationExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEmptyOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEmptyOperation.cs
index cc5b6b40a22a4..24d9c79d38c8d 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEmptyOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEmptyOperation.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IEmptyOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEventAssignmentExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEventAssignmentExpression.cs
index 168aae3a4f9e3..99d436592c653 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEventAssignmentExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEventAssignmentExpression.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IEventAssignmentExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEventReferenceOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEventReferenceOperation.cs
index 9b6f36e5cacf4..66439ed84a4b0 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEventReferenceOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IEventReferenceOperation.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IEventReferenceOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFieldReferenceExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFieldReferenceExpression.cs
index 688538f3b32a3..49dd0f3383748 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFieldReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFieldReferenceExpression.cs
@@ -14,7 +14,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IFieldReferenceExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFixedStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFixedStatement.cs
index d836d68b85833..d354529d6b3e2 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFixedStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFixedStatement.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IFixedStatement : SemanticModelTestBase
     {
         [Fact]
         [CompilerTrait(CompilerFeature.IOperation)]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IForEachLoopStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IForEachLoopStatement.cs
index 75dffb5e06385..b5131145b7ce3 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IForEachLoopStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IForEachLoopStatement.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IForEachLoopStatement : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(17602, "https://github.com/dotnet/roslyn/issues/17602")]
@@ -7186,7 +7186,7 @@ static class Extensions
 ");
         }
 
-        private static readonly string s_ValueTask = @"
+        internal static readonly string s_ValueTask = @"
 namespace System.Threading.Tasks
 {
     [System.Runtime.CompilerServices.AsyncMethodBuilder(typeof(System.Runtime.CompilerServices.ValueTaskMethodBuilder))]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IForLoopStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IForLoopStatement.cs
index faf59103a12f8..320bde4a041f8 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IForLoopStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IForLoopStatement.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IForLoopStatement : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(17602, "https://github.com/dotnet/roslyn/issues/17602")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFromEndIndexOperation_IRangeOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFromEndIndexOperation_IRangeOperation.cs
index 49bc4b0fa11b7..c2e97de085956 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFromEndIndexOperation_IRangeOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IFromEndIndexOperation_IRangeOperation.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IFromEndIndexOperation_IRangeOperation : SemanticModelTestBase
     {
         // The tests in this file right now are just to verify that we do not assert in the CFG builder. These need to be expanded.
         // https://github.com/dotnet/roslyn/issues/31545
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIfStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIfStatement.cs
index e48796636ef0b..2947b18096ec5 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIfStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIfStatement.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IIfStatement : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(17601, "https://github.com/dotnet/roslyn/issues/17601")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIncrementOrDecrementOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIncrementOrDecrementOperation.cs
index 94ba94905231f..f4bdde37c3706 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIncrementOrDecrementOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIncrementOrDecrementOperation.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IIncrementOrDecrementOperation : SemanticModelTestBase
     {
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInstanceReferenceTests.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInstanceReferenceTests.cs
index eb3f8f3a29bd5..938da2f88cd56 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInstanceReferenceTests.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInstanceReferenceTests.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IInstanceReferenceTests : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInterpolatedStringOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInterpolatedStringOperation.cs
index 9151e7b0e67aa..33cbbe46f7d03 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInterpolatedStringOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInterpolatedStringOperation.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IInterpolatedStringExpression : SemanticModelTestBase
     {
         private static CSharpTestSource GetSource(string code, bool hasDefaultHandler)
             => hasDefaultHandler
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInvocationOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInvocationOperation.cs
index d8565db64e062..7c9b02b8fa03a 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInvocationOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IInvocationOperation.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IInvocationOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIsPatternExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIsPatternExpression.cs
index 7fc105788d1fe..ad4eb2c03d86b 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIsPatternExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIsPatternExpression.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests_Patterns : SemanticModelTestBase
+    public class IOperationTests_IIsPatternExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Patterns)]
         [Fact, WorkItem(19927, "https://github.com/dotnet/roslyn/issues/19927")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIsTypeExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIsTypeExpression.cs
index 35d72d8065f10..af88fcb02c1ec 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIsTypeExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IIsTypeExpression.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IIsTypeExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILiteralOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILiteralOperation.cs
index 0fd704c26f2f0..ed16fbe7b568b 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILiteralOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILiteralOperation.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ILiteralOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILocalFunctionStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILocalFunctionStatement.cs
index d8beec109b789..f114020f0895f 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILocalFunctionStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILocalFunctionStatement.cs
@@ -15,7 +15,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ILocalFunctionStatement : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILocalReferenceExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILocalReferenceExpression.cs
index 97acfa6cf8ce5..11a7959e0fdf6 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILocalReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILocalReferenceExpression.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ILocalReferenceExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILockStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILockStatement.cs
index 45d6fbc7e36e6..a63d47c28e7b1 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILockStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ILockStatement.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ILockStatement : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IMethodBodyOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IMethodBodyOperation.cs
index 87441c6033d52..2eef8f4866d57 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IMethodBodyOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IMethodBodyOperation.cs
@@ -13,7 +13,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     [CompilerTrait(CompilerFeature.IOperation)]
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IMethodBodyOperation : SemanticModelTestBase
     {
         [Fact]
         public void RegularMethodBody_01()
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IMethodReferenceOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IMethodReferenceOperation.cs
index 4b719e8ea4855..6f3c64b5371f6 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IMethodReferenceOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IMethodReferenceOperation.cs
@@ -15,7 +15,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     [CompilerTrait(CompilerFeature.IOperation)]
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IMethodReferenceOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INameOfOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INameOfOperation.cs
index a5d4d9694ca68..f0d8101b04603 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INameOfOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INameOfOperation.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_INameOfOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INoPiaObjectCreationOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INoPiaObjectCreationOperation.cs
index a8d6d8411247c..dd483ca7d6366 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INoPiaObjectCreationOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INoPiaObjectCreationOperation.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_INoPiaObjectCreationOperation : SemanticModelTestBase
     {
 
         [CompilerTrait(CompilerFeature.IOperation)]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INoneOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INoneOperation.cs
index 6438f1d42dde9..488b6dd3a83aa 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INoneOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_INoneOperation.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_INoneOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IObjectCreationExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IObjectCreationExpression.cs
index fc94252b95daf..a5381332e247c 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IObjectCreationExpression.cs
@@ -13,7 +13,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IObjectCreationExpression : SemanticModelTestBase
     {
         private static readonly CSharpParseOptions ImplicitObjectCreationOptions = TestOptions.Regular9;
 
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParameterReferenceExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParameterReferenceExpression.cs
index ae7a0de3b6fbf..d9d84be826ad6 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParameterReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParameterReferenceExpression.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IParameterReferenceExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParenthesized.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParenthesized.cs
index 38d9cfc677c06..2addef8beec64 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParenthesized.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParenthesized.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IParenthesized : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPatternSwitchCase.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPatternSwitchCase.cs
index 4ac87953b94d5..d65131c77a69e 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPatternSwitchCase.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPatternSwitchCase.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests_Patterns : SemanticModelTestBase
+    public class IOperationTests_IPatternSwitchCase : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(19927, "https://github.com/dotnet/roslyn/issues/19927")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPointerIndirectionReferenceOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPointerIndirectionReferenceOperation.cs
index 954409dfeb5d6..62efe250cfe61 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPointerIndirectionReferenceOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPointerIndirectionReferenceOperation.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests.IOperation
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IPointerIndirectionReferenceOperation : SemanticModelTestBase
     {
         //Currently, we are not creating the IPointerIndirectionReferenceOperation node
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPropertyReferenceExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPropertyReferenceExpression.cs
index a4e6582a00175..065bc15ae248f 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPropertyReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IPropertyReferenceExpression.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IPropertyReferenceExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation), WorkItem(21769, "https://github.com/dotnet/roslyn/issues/21769")]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IReturnStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IReturnStatement.cs
index 78ba6e7dab2a0..a363ca4aff9ff 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IReturnStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IReturnStatement.cs
@@ -14,7 +14,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IReturnStatement : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISizeOfExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISizeOfExpression.cs
index e10fa4ccba866..e2a8522bde013 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISizeOfExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISizeOfExpression.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ISizeOfExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISwitchExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISwitchExpression.cs
index 3d165da312198..5dc4299e1cd95 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISwitchExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISwitchExpression.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests_SwitchExpression : SemanticModelTestBase
+    public class IOperationTests_ISwitchExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Patterns)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISwitchOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISwitchOperation.cs
index 099de612ad487..e3207923caad1 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISwitchOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISwitchOperation.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests_Patterns : SemanticModelTestBase
+    public class IOperationTests_ISwitchOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISymbolInitializer.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISymbolInitializer.cs
index 152a0fde829df..6924cc0b9f199 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISymbolInitializer.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ISymbolInitializer.cs
@@ -13,7 +13,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ISymbolInitializer : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(17595, "https://github.com/dotnet/roslyn/issues/17595")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IThrowOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IThrowOperation.cs
index e2bf7d89dfc02..06b66d0f38179 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IThrowOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IThrowOperation.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IThrowOperation : SemanticModelTestBase
     {
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITranslatedQueryOperation.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITranslatedQueryOperation.cs
index ebb572ad36fd0..c9e8747778027 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITranslatedQueryOperation.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITranslatedQueryOperation.cs
@@ -15,7 +15,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ITranslatedQueryOperation : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITupleBinaryOperatorExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITupleBinaryOperatorExpression.cs
index 936bf99ecfd36..c064ca3925649 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITupleBinaryOperatorExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITupleBinaryOperatorExpression.cs
@@ -13,7 +13,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     [CompilerTrait(CompilerFeature.IOperation)]
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ITupleBinaryOperatorExpression : SemanticModelTestBase
     {
         [Fact]
         public void VerifyTupleEqualityBinaryOperator()
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITupleExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITupleExpression.cs
index b5e04e597567c..c86861a7cb158 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITupleExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITupleExpression.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ITupleExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(10856, "https://github.com/dotnet/roslyn/issues/10856")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITypeOfExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITypeOfExpression.cs
index 753785f342031..4d995972f086e 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITypeOfExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITypeOfExpression.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ITypeOfExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITypeParameterObjectCreationTests.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITypeParameterObjectCreationTests.cs
index 73c0f6dd1a6dd..53a87be4275b9 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITypeParameterObjectCreationTests.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_ITypeParameterObjectCreationTests.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_ITypeParameterObjectCreationTests : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUnaryOperatorExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUnaryOperatorExpression.cs
index cce9fba4eac7e..e8b7c78e00869 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUnaryOperatorExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUnaryOperatorExpression.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IUnaryOperatorExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(17595, "https://github.com/dotnet/roslyn/issues/17591")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUsingStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUsingStatement.cs
index 77d4298dd2c41..d957174177441 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUsingStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUsingStatement.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IUsingStatement : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
@@ -123,7 +123,7 @@ public static async Task M1(IAsyncDisposable disposable)
 ";
 
             var expectedDiagnostics = DiagnosticDescription.None;
-            VerifyOperationTreeAndDiagnosticsForTest<UsingStatementSyntax>(source + s_IAsyncEnumerable + s_ValueTask, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<UsingStatementSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedOperationTree, expectedDiagnostics);
         }
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow, CompilerFeature.AsyncStreams)]
@@ -219,7 +219,7 @@ public static async Task M1(IAsyncDisposable disposable)
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + s_ValueTask, expectedGraph, expectedDiagnostics);
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
         }
 
         [CompilerTrait(CompilerFeature.IOperation)]
@@ -4208,7 +4208,7 @@ public async Task M()
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + s_ValueTask, expectedGraph, expectedDiagnostics);
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
         }
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
@@ -4302,7 +4302,7 @@ Element Values(0)
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + s_ValueTask, expectedGraph, expectedDiagnostics);
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
         }
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
@@ -4388,7 +4388,7 @@ Element Values(0)
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + s_ValueTask, expectedGraph, expectedDiagnostics);
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
         }
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
@@ -4480,7 +4480,7 @@ public async Task M()
                 Diagnostic(ErrorCode.ERR_ParamsLast, "params int[] extras").WithLocation(11, 34)
             };
 
-            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + s_ValueTask, expectedGraph, expectedDiagnostics);
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
         }
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
@@ -7467,7 +7467,7 @@ async Task M(bool b)
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + s_ValueTask, expectedGraph, expectedDiagnostics);
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
         }
 
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow)]
@@ -7565,7 +7565,7 @@ Element Values(0)
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + s_ValueTask, expectedGraph, expectedDiagnostics);
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
         }
 
 
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IVariableDeclaration.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IVariableDeclaration.cs
index 40a5b1d08b621..7bd6f23a1073a 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IVariableDeclaration.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IVariableDeclaration.cs
@@ -14,7 +14,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IVariableDeclaration : SemanticModelTestBase
     {
         #region Variable Declarations
 
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IWhileUntilLoopStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IWhileUntilLoopStatement.cs
index 44a47dc526152..fb764fa915562 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IWhileUntilLoopStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IWhileUntilLoopStatement.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_IWhileUntilLoopStatement : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(17602, "https://github.com/dotnet/roslyn/issues/17602")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_InvalidExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_InvalidExpression.cs
index f305a8ac4c238..ea66773bb012a 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_InvalidExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_InvalidExpression.cs
@@ -13,7 +13,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_InvalidExpression : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(17598, "https://github.com/dotnet/roslyn/issues/17598")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_InvalidStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_InvalidStatement.cs
index 4c7dc839b84bc..7ad9585a3b98c 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_InvalidStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_InvalidStatement.cs
@@ -13,7 +13,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_InvalidStatement : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact, WorkItem(17607, "https://github.com/dotnet/roslyn/issues/17607")]
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_StackAllocArrayCreationAndInitializer.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_StackAllocArrayCreationAndInitializer.cs
index 3e1cd3ad9adf8..cb5326df6ba22 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_StackAllocArrayCreationAndInitializer.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_StackAllocArrayCreationAndInitializer.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_StackAllocArrayCreationAndInitializer : SemanticModelTestBase
     {
         [Fact]
         public void SimpleStackAllocArrayCreation_PrimitiveType()
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_TryCatch.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_TryCatch.cs
index 5564db8b0a01d..7371523f6d2e2 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_TryCatch.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_TryCatch.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
-    public partial class IOperationTests : SemanticModelTestBase
+    public class IOperationTests_TryCatch : SemanticModelTestBase
     {
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/AwaitExpressionTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/AwaitExpressionTests.cs
index ff547024e3d84..dd27e4aff990f 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/AwaitExpressionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/AwaitExpressionTests.cs
@@ -20,6 +20,85 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests
     /// </summary>
     public class AwaitExpressionTests : CompilingTestBase
     {
+        [Fact]
+        public void TestAwaitInfoExtensionMethod()
+        {
+            var text =
+@"using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+static class App{
+    public static async Task Main(){
+        var x = new MyAwaitable();
+        x.SetValue(42);
+
+        Console.WriteLine(await x + ""!"");
+    }
+}
+
+struct MyAwaitable
+{
+    private ValueTask<int> task;
+    private TaskCompletionSource<int> source;
+
+    private TaskCompletionSource<int> Source
+    {
+        get
+        {
+            if (source == null)
+            {
+                source = new TaskCompletionSource<int>();
+                task = new ValueTask<int>(source.Task);
+            }
+            return source;
+        }
+    }
+    internal ValueTask<int> Task
+    {
+        get
+        {
+            _ = Source;
+            return task;
+        }
+    }
+
+    public void SetValue(int i)
+    {
+        Source.SetResult(i);
+    }
+}
+
+static class MyAwaitableExtension
+{
+    public static System.Runtime.CompilerServices.ValueTaskAwaiter<int> GetAwaiter(this MyAwaitable a)
+    {
+        return a.Task.GetAwaiter();
+    }
+}";
+
+            var csCompilation = CreateCompilation(text, targetFramework: TargetFramework.NetCoreAppAndCSharp);
+            var tree = csCompilation.SyntaxTrees.Single();
+
+            var model = csCompilation.GetSemanticModel(tree);
+            var awaitExpression = tree.GetRoot().DescendantNodes().OfType<AwaitExpressionSyntax>().First();
+            Assert.Equal("await x", awaitExpression.ToString());
+
+            var info = model.GetAwaitExpressionInfo(awaitExpression);
+            Assert.Equal(
+                "System.Runtime.CompilerServices.ValueTaskAwaiter<System.Int32> MyAwaitableExtension.GetAwaiter(this MyAwaitable a)",
+                info.GetAwaiterMethod.ToTestDisplayString()
+            );
+            Assert.Equal(
+                "System.Int32 System.Runtime.CompilerServices.ValueTaskAwaiter<System.Int32>.GetResult()",
+                info.GetResultMethod.ToTestDisplayString()
+            );
+            Assert.Equal(
+                "System.Boolean System.Runtime.CompilerServices.ValueTaskAwaiter<System.Int32>.IsCompleted { get; }",
+                info.IsCompletedProperty.ToTestDisplayString()
+            );
+        }
+
         [Fact]
         [WorkItem(711413, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/711413")]
         public void TestAwaitInfo()
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTasklikeMoreTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTasklikeMoreTests.cs
index 58ea912c7c82c..fbf712806045b 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTasklikeMoreTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTasklikeMoreTests.cs
@@ -109,10 +109,10 @@ namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute :
             var testData = verifier.TestData;
             var method = (MethodSymbol)testData.GetMethodData("C.F()").Method;
             Assert.True(method.IsAsync);
-            Assert.True(method.IsAsyncReturningTask(compilation));
+            Assert.True(method.IsAsyncEffectivelyReturningTask(compilation));
             method = (MethodSymbol)testData.GetMethodData("C.G<T>(T)").Method;
             Assert.True(method.IsAsync);
-            Assert.True(method.IsAsyncReturningGenericTask(compilation));
+            Assert.True(method.IsAsyncEffectivelyReturningGenericTask(compilation));
             verifier.VerifyIL("C.F()",
 @"{
   // Code size       49 (0x31)
@@ -162,6 +162,186 @@ .locals init (C.<G>d__1<T> V_0)
 }");
         }
 
+        [Fact]
+        public void AsyncMethod_CreateHasRefReturn()
+        {
+            var source =
+@"using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{
+    static async MyTask F() { await Task.Delay(0); }
+    static async MyTask<T> G<T>(T t) { await Task.Delay(0); return t; }
+    static async MyTask<int> M() { await F(); return await G(3); }
+}
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+struct MyTask
+{
+    internal Awaiter GetAwaiter() => new Awaiter();
+    internal class Awaiter : INotifyCompletion
+    {
+        public void OnCompleted(Action a) { }
+        internal bool IsCompleted => true;
+        internal void GetResult() { }
+    }
+}
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder<>))]
+struct MyTask<T>
+{
+    internal T _result;
+    public T Result => _result;
+    internal Awaiter GetAwaiter() => new Awaiter(this);
+    internal class Awaiter : INotifyCompletion
+    {
+        private readonly MyTask<T> _task;
+        internal Awaiter(MyTask<T> task) { _task = task; }
+        public void OnCompleted(Action a) { }
+        internal bool IsCompleted => true;
+        internal T GetResult() => _task.Result;
+    }
+}
+struct MyTaskMethodBuilder
+{
+    private MyTask _task;
+    public static ref MyTaskMethodBuilder Create() => throw null;
+    internal MyTaskMethodBuilder(MyTask task) { _task = task; }
+    public void SetStateMachine(IAsyncStateMachine stateMachine) { }
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine { stateMachine.MoveNext(); }
+    public void SetException(Exception e) { }
+    public void SetResult() { }
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public MyTask Task => _task;
+}
+struct MyTaskMethodBuilder<T>
+{
+    private MyTask<T> _task;
+    public static ref MyTaskMethodBuilder<T> Create() => throw null;
+    internal MyTaskMethodBuilder(MyTask<T> task) { _task = task; }
+    public void SetStateMachine(IAsyncStateMachine stateMachine) { }
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine { stateMachine.MoveNext(); }
+    public void SetException(Exception e) { }
+    public void SetResult(T t) { _task._result = t; }
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public MyTask<T> Task => _task;
+}
+
+namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute : System.Attribute { public AsyncMethodBuilderAttribute(System.Type t) { } } }
+";
+            var compilation = CreateCompilationWithMscorlib45(source);
+            compilation.VerifyEmitDiagnostics(
+                // (6,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilder.Create'
+                //     static async MyTask F() { await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "{ await Task.Delay(0); }").WithArguments("MyTaskMethodBuilder", "Create").WithLocation(6, 29),
+                // (7,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "{ await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilder<T>", "Create").WithLocation(7, 38),
+                // (8,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilder<int>.Create'
+                //     static async MyTask<int> M() { await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "{ await F(); return await G(3); }").WithArguments("MyTaskMethodBuilder<int>", "Create").WithLocation(8, 34)
+                );
+        }
+
+        [Fact]
+        public void AsyncMethod_BuilderFactoryDisallowed()
+        {
+            // Only method-level builder overrides allow having Create() return a different builder
+            var source =
+@"using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+class C
+{
+    static async MyTask F() { await Task.Delay(0); }
+    static async MyTask<T> G<T>(T t) { await Task.Delay(0); return t; }
+    static async MyTask<int> M() { await F(); return await G(3); }
+}
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilderFactory))]
+struct MyTask
+{
+    internal Awaiter GetAwaiter() => new Awaiter();
+    internal class Awaiter : INotifyCompletion
+    {
+        public void OnCompleted(Action a) { }
+        internal bool IsCompleted => true;
+        internal void GetResult() { }
+    }
+}
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilderFactory<>))]
+struct MyTask<T>
+{
+    internal T _result;
+    public T Result => _result;
+    internal Awaiter GetAwaiter() => new Awaiter(this);
+    internal class Awaiter : INotifyCompletion
+    {
+        private readonly MyTask<T> _task;
+        internal Awaiter(MyTask<T> task) { _task = task; }
+        public void OnCompleted(Action a) { }
+        internal bool IsCompleted => true;
+        internal T GetResult() => _task.Result;
+    }
+}
+struct MyTaskMethodBuilderFactory
+{
+    public static MyTaskMethodBuilder Create() => throw null;
+}
+struct MyTaskMethodBuilder
+{
+    private MyTask _task;
+    internal MyTaskMethodBuilder(MyTask task) { _task = task; }
+    public void SetStateMachine(IAsyncStateMachine stateMachine) { }
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine { stateMachine.MoveNext(); }
+    public void SetException(Exception e) { }
+    public void SetResult() { }
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public MyTask Task => _task;
+}
+struct MyTaskMethodBuilderFactory<T>
+{
+    public static MyTaskMethodBuilder<T> Create() => throw null;
+}
+struct MyTaskMethodBuilder<T>
+{
+    private MyTask<T> _task;
+    internal MyTaskMethodBuilder(MyTask<T> task) { _task = task; }
+    public void SetStateMachine(IAsyncStateMachine stateMachine) { }
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine { stateMachine.MoveNext(); }
+    public void SetException(Exception e) { }
+    public void SetResult(T t) { _task._result = t; }
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public MyTask<T> Task => _task;
+}
+
+namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute : System.Attribute { public AsyncMethodBuilderAttribute(System.Type t) { } } }
+";
+            var compilation = CreateCompilationWithMscorlib45(source);
+            compilation.VerifyEmitDiagnostics(
+                // (6,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory.Task'
+                //     static async MyTask F() { await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "{ await Task.Delay(0); }").WithArguments("MyTaskMethodBuilderFactory", "Task").WithLocation(6, 29),
+                // (6,29): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory.Create'
+                //     static async MyTask F() { await Task.Delay(0); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "{ await Task.Delay(0); }").WithArguments("MyTaskMethodBuilderFactory", "Create").WithLocation(6, 29),
+                // (7,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory<T>.Task'
+                //     static async MyTask<T> G<T>(T t) { await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "{ await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilderFactory<T>", "Task").WithLocation(7, 38),
+                // (7,38): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory<T>.Create'
+                //     static async MyTask<T> G<T>(T t) { await Task.Delay(0); return t; }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "{ await Task.Delay(0); return t; }").WithArguments("MyTaskMethodBuilderFactory<T>", "Create").WithLocation(7, 38),
+                // (8,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory<int>.Task'
+                //     static async MyTask<int> M() { await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "{ await F(); return await G(3); }").WithArguments("MyTaskMethodBuilderFactory<int>", "Task").WithLocation(8, 34),
+                // (8,34): error CS0656: Missing compiler required member 'MyTaskMethodBuilderFactory<int>.Create'
+                //     static async MyTask<int> M() { await F(); return await G(3); }
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "{ await F(); return await G(3); }").WithArguments("MyTaskMethodBuilderFactory<int>", "Create").WithLocation(8, 34)
+                );
+        }
+
         [Fact]
         public void AsyncMethodBuilder_MissingMethods()
         {
@@ -254,11 +434,11 @@ namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute :
             var testData = verifier.TestData;
             var method = (MethodSymbol)testData.GetMethodData("C.F()").Method;
             Assert.True(method.IsAsync);
-            Assert.True(method.IsAsyncReturningTask(compilation));
+            Assert.True(method.IsAsyncEffectivelyReturningTask(compilation));
             Assert.Equal("C.MyTask", method.ReturnTypeWithAnnotations.ToDisplayString());
             method = (MethodSymbol)testData.GetMethodData("C.G()").Method;
             Assert.True(method.IsAsync);
-            Assert.True(method.IsAsyncReturningGenericTask(compilation));
+            Assert.True(method.IsAsyncEffectivelyReturningGenericTask(compilation));
             Assert.Equal("C.MyTask<int>", method.ReturnTypeWithAnnotations.ToDisplayString());
         }
 
@@ -335,11 +515,11 @@ namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute :
             var testData = verifier.TestData;
             var method = (MethodSymbol)testData.GetMethodData("C.<>c.<M>b__3_0()").Method;
             Assert.True(method.IsAsync);
-            Assert.True(method.IsAsyncReturningTask(compilation));
+            Assert.True(method.IsAsyncEffectivelyReturningTask(compilation));
             Assert.Equal("MyTask", method.ReturnTypeWithAnnotations.ToDisplayString());
             method = (MethodSymbol)testData.GetMethodData("C.<>c.<M>b__3_1()").Method;
             Assert.True(method.IsAsync);
-            Assert.True(method.IsAsyncReturningGenericTask(compilation));
+            Assert.True(method.IsAsyncEffectivelyReturningGenericTask(compilation));
             Assert.Equal("MyTask<int>", method.ReturnTypeWithAnnotations.ToDisplayString());
         }
 
@@ -414,11 +594,11 @@ namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute :
             var testData = verifier.TestData;
             var method = (MethodSymbol)testData.GetMethodData("C.<M>g__F|0_0()").Method;
             Assert.True(method.IsAsync);
-            Assert.True(method.IsAsyncReturningTask(compilation));
+            Assert.True(method.IsAsyncEffectivelyReturningTask(compilation));
             Assert.Equal("MyTask", method.ReturnTypeWithAnnotations.ToDisplayString());
             method = (MethodSymbol)testData.GetMethodData("C.<M>g__G|0_1<T>(T)").Method;
             Assert.True(method.IsAsync);
-            Assert.True(method.IsAsyncReturningGenericTask(compilation));
+            Assert.True(method.IsAsyncEffectivelyReturningGenericTask(compilation));
             Assert.Equal("MyTask<T>", method.ReturnTypeWithAnnotations.ToDisplayString());
         }
 
@@ -605,7 +785,7 @@ namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute :
         }
 
         [Fact]
-        static void AsyncMethodBuilderAttributeMultipleParameters()
+        public static void AsyncMethodBuilderAttributeMultipleParameters()
         {
             var source = @"
 using System.Runtime.CompilerServices;
@@ -640,7 +820,7 @@ namespace System.Runtime.CompilerServices { class AsyncMethodBuilderAttribute :
         }
 
         [Fact]
-        static void AsyncMethodBuilderAttributeSingleParameterWrong()
+        public static void AsyncMethodBuilderAttributeSingleParameterWrong()
         {
             var source = @"
 using System.Runtime.CompilerServices;
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingTests.cs
index 5b29dc781eef4..1574892347516 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingTests.cs
@@ -246,9 +246,6 @@ static void M(A a)
                 // (11,9): error CS1656: Cannot assign to 'E' because it is a 'method group'
                 //         a.E += a.E;
                 Diagnostic(ErrorCode.ERR_AssgReadonlyLocalCause, "a.E").WithArguments("E", "method group").WithLocation(11, 9),
-                // (12,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                //         if (a.E != null)
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "a.E").WithArguments("inferred delegate type").WithLocation(12, 13),
                 // (14,15): error CS1503: Argument 1: cannot convert from 'method group' to 'A'
                 //             M(a.E);
                 Diagnostic(ErrorCode.ERR_BadArgType, "a.E").WithArguments("1", "method group", "A").WithLocation(14, 15),
@@ -1887,9 +1884,10 @@ internal static virtual void M4<T>() { }
                 // (9,17): error CS0238: 'C.M3<T>()' cannot be sealed because it is not an override
                 //     sealed void M3<T>() { }
                 Diagnostic(ErrorCode.ERR_SealedNonOverride, "M3").WithArguments("C.M3<T>()").WithLocation(9, 17),
-                // (10,34): error CS0112: A static member 'C.M4<T>()' cannot be marked as override, virtual, or abstract
+                // (10,34): error CS0112: A static member cannot be marked as 'virtual'
                 //     internal static virtual void M4<T>() { }
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M4").WithArguments("C.M4<T>()").WithLocation(10, 34));
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M4").WithArguments("virtual").WithLocation(10, 34)
+                );
         }
 
         [WorkItem(542391, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542391")]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/ConstantTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/ConstantTests.cs
index e33614276b71e..a963782c19e28 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/ConstantTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/ConstantTests.cs
@@ -3727,65 +3727,65 @@ void M2(string S1 = $""Testing"", object O = null, Namae N = null)
         }
     }
 }";
-            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics(
                     // (32,27): error CS0133: The expression being assigned to 'S6' must be constant
                     //         const string S6 = $"Failed to {VS}";
                     Diagnostic(ErrorCode.ERR_NotConstantExpression, @"$""Failed to {VS}""").WithArguments("S6").WithLocation(34, 27));
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.Regular8);
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                    // (12,4): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    // (12,4): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     // [A($"ITEM")]
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""ITEM""").WithArguments("constant interpolated strings").WithLocation(12, 4),
-                    // (15,23): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""ITEM""").WithArguments("constant interpolated strings", "10.0").WithLocation(12, 4),
+                    // (15,23): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //     const string S0 = $"Post";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""Post""").WithArguments("constant interpolated strings").WithLocation(15, 23),
-                    // (25,27): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""Post""").WithArguments("constant interpolated strings", "10.0").WithLocation(15, 23),
+                    // (25,27): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //         const string S1 = $"Testing";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""Testing""").WithArguments("constant interpolated strings").WithLocation(25, 27),
-                    // (26,27): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""Testing""").WithArguments("constant interpolated strings", "10.0").WithLocation(25, 27),
+                    // (26,27): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //         const string S2 = $"{"Level 5"} {"Number 3"}";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""{""Level 5""} {""Number 3""}""").WithArguments("constant interpolated strings").WithLocation(26, 27),
-                    // (27,27): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""{""Level 5""} {""Number 3""}""").WithArguments("constant interpolated strings", "10.0").WithLocation(26, 27),
+                    // (27,27): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //         const string S3 = $"{$"{"Spinning Top"}"}";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""{$""{""Spinning Top""}""}""").WithArguments("constant interpolated strings").WithLocation(27, 27),
-                    // (28,27): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""{$""{""Spinning Top""}""}""").WithArguments("constant interpolated strings", "10.0").WithLocation(27, 27),
+                    // (28,27): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //         const string S4 = $"Hybrid" + "Testing" + "123";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""Hybrid""").WithArguments("constant interpolated strings").WithLocation(28, 27),
-                    // (29,50): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""Hybrid""").WithArguments("constant interpolated strings", "10.0").WithLocation(28, 27),
+                    // (29,50): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //         const string S5 = "Hybrid" + "Testing" + $"321";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""321""").WithArguments("constant interpolated strings").WithLocation(29, 50),
-                    // (30,27): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""321""").WithArguments("constant interpolated strings", "10.0").WithLocation(29, 50),
+                    // (30,27): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //         const string F1 = $"{S1}";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""{S1}""").WithArguments("constant interpolated strings").WithLocation(30, 27),
-                    // (31,32): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""{S1}""").WithArguments("constant interpolated strings", "10.0").WithLocation(30, 27),
+                    // (31,32): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //         const string F2 = F1 + $" the {S2}";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$"" the {S2}""").WithArguments("constant interpolated strings").WithLocation(31, 32),
-                    // (34,27): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$"" the {S2}""").WithArguments("constant interpolated strings", "10.0").WithLocation(31, 32),
+                    // (34,27): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //         const string S6 = $"Failed to {VS}";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""Failed to {VS}""").WithArguments("constant interpolated strings").WithLocation(34, 27),
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""Failed to {VS}""").WithArguments("constant interpolated strings", "10.0").WithLocation(34, 27),
                     // (34,27): error CS0133: The expression being assigned to 'S6' must be constant
                     //         const string S6 = $"Failed to {VS}";
                     Diagnostic(ErrorCode.ERR_NotConstantExpression, @"$""Failed to {VS}""").WithArguments("S6").WithLocation(34, 27),
-                    // (37,25): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    // (37,25): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //     void M2(string S1 = $"Testing", object O = null, Namae N = null)
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""Testing""").WithArguments("constant interpolated strings").WithLocation(37, 25),
-                    // (40,18): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""Testing""").WithArguments("constant interpolated strings", "10.0").WithLocation(37, 25),
+                    // (40,18): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //             case $"Level 5":
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""Level 5""").WithArguments("constant interpolated strings").WithLocation(40, 18),
-                    // (44,30): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""Level 5""").WithArguments("constant interpolated strings", "10.0").WithLocation(40, 18),
+                    // (44,30): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //         if (N is Namae { X : $"ConstantInterpolatedString"}){
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""ConstantInterpolatedString""").WithArguments("constant interpolated strings").WithLocation(44, 30),
-                    // (46,22): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""ConstantInterpolatedString""").WithArguments("constant interpolated strings", "10.0").WithLocation(44, 30),
+                    // (46,22): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //                 case $"Number 3":
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""Number 3""").WithArguments("constant interpolated strings").WithLocation(46, 22),
-                    // (48,22): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""Number 3""").WithArguments("constant interpolated strings", "10.0").WithLocation(46, 22),
+                    // (48,22): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //                 case $"Radio Noise":
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""Radio Noise""").WithArguments("constant interpolated strings").WithLocation(48, 22),
-                    // (49,31): error CS8652: The feature 'constant interpolated strings' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""Radio Noise""").WithArguments("constant interpolated strings", "10.0").WithLocation(48, 22),
+                    // (49,31): error CS8773: Feature 'constant interpolated strings' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //                     goto case $"Number 3";
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, @"$""Number 3""").WithArguments("constant interpolated strings").WithLocation(49, 31));
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, @"$""Number 3""").WithArguments("constant interpolated strings", "10.0").WithLocation(49, 31));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
index 6c601d03f70a6..f911fc9fe74fe 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
@@ -73,20 +73,20 @@ static void Main()
 
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (6,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (6,13): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         d = Main;
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "Main").WithArguments("inferred delegate type").WithLocation(6, 13),
-                // (7,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "Main").WithArguments("inferred delegate type", "10.0").WithLocation(6, 13),
+                // (7,13): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         d = () => { };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => { }").WithArguments("inferred delegate type").WithLocation(7, 13),
-                // (8,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "() => { }").WithArguments("inferred delegate type", "10.0").WithLocation(7, 13),
+                // (8,13): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         d = delegate () { };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "delegate () { }").WithArguments("inferred delegate type").WithLocation(8, 13),
-                // (9,48): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "delegate () { }").WithArguments("inferred delegate type", "10.0").WithLocation(8, 13),
+                // (9,48): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         System.Linq.Expressions.Expression e = () => 1;
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => 1").WithArguments("inferred delegate type").WithLocation(9, 48));
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "() => 1").WithArguments("inferred delegate type", "10.0").WithLocation(9, 48));
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics();
         }
 
@@ -303,6 +303,8 @@ static void Main()
             yield return getData("(int i) => { if (i > 0) return i; return default; }", "System.Func<System.Int32, System.Int32>");
             yield return getData("(int x, short y) => { if (x > 0) return x; return y; }", "System.Func<System.Int32, System.Int16, System.Int32>");
             yield return getData("(int x, short y) => { if (x > 0) return y; return x; }", "System.Func<System.Int32, System.Int16, System.Int32>");
+            yield return getData("object () => default", "System.Func<System.Object>");
+            yield return getData("void () => { }", "System.Action");
 
             static object?[] getData(string expr, string? expectedType) =>
                 new object?[] { expr, expectedType };
@@ -1816,15 +1818,15 @@ static class E
 
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (7,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                //         c.M(Main);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "Main").WithArguments("inferred delegate type").WithLocation(7, 13),
-                // (8,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                //         c.M(() => { });
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => { }").WithArguments("inferred delegate type").WithLocation(8, 13));
+                // (7,13): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //         c.M(Main);      // C#9: E.M(object x, Action y)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "Main").WithArguments("inferred delegate type", "10.0").WithLocation(7, 13),
+                // (8,13): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //         c.M(() => { }); // C#9: E.M(object x, Action y)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "() => { }").WithArguments("inferred delegate type", "10.0").WithLocation(8, 13));
 
             // Breaking change from C#9 which binds to E.M.
-            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput:
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput:
 @"C.M
 C.M
 ");
@@ -1856,12 +1858,12 @@ static class E
 
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (8,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (8,13): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         c.M(() => 1);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => 1").WithArguments("inferred delegate type").WithLocation(8, 13));
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "() => 1").WithArguments("inferred delegate type", "10.0").WithLocation(8, 13));
 
             // Breaking change from C#9 which binds to E.M.
-            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput: @"C.M");
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: @"C.M");
         }
 
         [Fact]
@@ -1897,26 +1899,26 @@ static void Main()
 
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (14,12): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (14,12): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         FA(F2);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "F2").WithArguments("inferred delegate type").WithLocation(14, 12),
-                // (15,12): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "F2").WithArguments("inferred delegate type", "10.0").WithLocation(14, 12),
+                // (15,12): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         FB(F1);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "F1").WithArguments("inferred delegate type").WithLocation(15, 12),
-                // (18,12): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "F1").WithArguments("inferred delegate type", "10.0").WithLocation(15, 12),
+                // (18,12): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         FA(() => 0);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => 0").WithArguments("inferred delegate type").WithLocation(18, 12),
-                // (19,12): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "() => 0").WithArguments("inferred delegate type", "10.0").WithLocation(18, 12),
+                // (19,12): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         FB(() => { });
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => { }").WithArguments("inferred delegate type").WithLocation(19, 12),
-                // (22,12): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "() => { }").WithArguments("inferred delegate type", "10.0").WithLocation(19, 12),
+                // (22,12): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         FA(delegate () { return 0; });
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "delegate () { return 0; }").WithArguments("inferred delegate type").WithLocation(22, 12),
-                // (23,12): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "delegate () { return 0; }").WithArguments("inferred delegate type", "10.0").WithLocation(22, 12),
+                // (23,12): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         FB(delegate () { });
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "delegate () { }").WithArguments("inferred delegate type").WithLocation(23, 12));
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "delegate () { }").WithArguments("inferred delegate type", "10.0").WithLocation(23, 12));
 
-            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput:
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput:
 @"FA(Action)
 FA(Delegate)
 FB(Delegate)
@@ -1952,11 +1954,11 @@ static void Main()
 
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (11,11): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (11,11): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         F(() => string.Empty);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => string.Empty").WithArguments("inferred delegate type").WithLocation(11, 11));
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "() => string.Empty").WithArguments("inferred delegate type", "10.0").WithLocation(11, 11));
 
-            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput:
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput:
 @"F(Expression<Func<int>>): () => 0
 F(Expression): () => String.Empty
 ");
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs
index 2e597b7498082..c4cfb87ed8580 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs
@@ -44,7 +44,12 @@ public void UsingAliasTest()
                 Diagnostic(ErrorCode.ERR_IdentifierExpectedKW, "delegate").WithArguments("", "delegate").WithLocation(2, 11),
                 // (2,25): error CS0116: A namespace cannot directly contain members such as fields or methods
                 // using s = delegate*<void>;
-                Diagnostic(ErrorCode.ERR_NamespaceUnexpected, ">").WithLocation(2, 25)
+                Diagnostic(ErrorCode.ERR_NamespaceUnexpected, ">").WithLocation(2, 25),
+
+                // See same-named test in TopLevelStatementsParsingTests, there is a single top-level statement in the tree and it is an empty statement.
+                // (2,26): error CS8937: At least one top-level statement must be non-empty.
+                // using s = delegate*<void>;
+                Diagnostic(ErrorCode.ERR_SimpleProgramIsEmpty, ";").WithLocation(2, 26)
             );
         }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/GlobalUsingDirectiveTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/GlobalUsingDirectiveTests.cs
index ed1ed989e9023..35eb4bc5d2573 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/GlobalUsingDirectiveTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/GlobalUsingDirectiveTests.cs
@@ -33,7 +33,19 @@ namespace ns2 {}
 namespace ns3 {}
 namespace ns4 {}
 ";
-            CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
+            CreateCompilation(source, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
+                // (4,1): error CS8773: Feature 'global using directive' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // global using ns1;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "global using ns1;").WithArguments("global using directive", "10.0").WithLocation(4, 1),
+                // (6,1): error CS8773: Feature 'global using directive' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // global using ns3;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "global using ns3;").WithArguments("global using directive", "10.0").WithLocation(6, 1),
+                // (6,1): error CS8915: A global using directive must precede all non-global using directives.
+                // global using ns3;
+                Diagnostic(ErrorCode.ERR_GlobalUsingOutOfOrder, "global").WithLocation(6, 1)
+                );
+
+            CreateCompilation(source, parseOptions: TestOptions.Regular10).VerifyDiagnostics(
                 // (6,1): error CS9002: A global using directive must precede all non-global using directives.
                 // global using ns3;
                 Diagnostic(ErrorCode.ERR_GlobalUsingOutOfOrder, "global").WithLocation(6, 1)
@@ -52,7 +64,7 @@ public void MixingUsings_02()
 namespace ns1 {}
 namespace ns3 {}
 ";
-            CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics();
+            CreateCompilation(source, parseOptions: TestOptions.Regular10).VerifyDiagnostics();
         }
 
         [Fact]
@@ -177,7 +189,7 @@ static void Main()
     }
 }
 ";
-            var comp2 = CreateCompilation(source2, parseOptions: TestOptions.RegularPreview, options: TestOptions.DebugExe, references: new[] { comp1Ref });
+            var comp2 = CreateCompilation(source2, parseOptions: TestOptions.Regular10, options: TestOptions.DebugExe, references: new[] { comp1Ref });
 
             CompileAndVerify(comp2, expectedOutput: @"
 C1
@@ -220,7 +232,7 @@ static void Main()
     }
 }
 ";
-            var comp3 = CreateCompilation(source3, parseOptions: TestOptions.RegularPreview, options: TestOptions.DebugExe, references: new[] { comp1Ref });
+            var comp3 = CreateCompilation(source3, parseOptions: TestOptions.Regular10, options: TestOptions.DebugExe, references: new[] { comp1Ref });
 
             CompileAndVerify(comp3, expectedOutput: @"
 C1
@@ -290,7 +302,7 @@ public static void Test()
     }
 }
 ";
-            var comp2 = CreateCompilation(source2, parseOptions: TestOptions.RegularPreview, options: TestOptions.DebugExe, references: new[] { comp1Ref });
+            var comp2 = CreateCompilation(source2, parseOptions: TestOptions.Regular10, options: TestOptions.DebugExe, references: new[] { comp1Ref });
 
             CompileAndVerify(comp2, expectedOutput: @"
 C1
@@ -2538,44 +2550,73 @@ class C2 {}
 
             var expected1 = new[]
             {
-                // (3000,14): warning CS0105: The using directive for 'C2' appeared previously in this namespace
+                // (3000,14): hidden CS8933: The using directive for 'C2' appeared previously as global using
                 // using static C2;
-                Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(3000, 14)
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(3000, 14)
             };
 
-            comp2.GetDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected1);
+            CompileAndVerify(comp2).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected1);
 
             var comp3 = CreateCompilation(new[] { source3 + source4, source5, source6 }, parseOptions: TestOptions.RegularPreview);
 
-            var expected2 = new[]
-            {
+            CompileAndVerify(comp3).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
                 // (2000,21): warning CS0105: The using directive for 'C2' appeared previously in this namespace
                 // global using static C2;
                 Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(2000, 21),
-                // (3000,14): warning CS0105: The using directive for 'C2' appeared previously in this namespace
+                // (3000,14): hidden CS8933: The using directive for 'C2' appeared previously as global using
                 // using static C2;
-                Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(3000, 14)
-            };
-
-            comp3.GetDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected2);
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(3000, 14)
+                );
 
             var comp4 = CreateCompilation(new[] { source3 + source5, source6 }, parseOptions: TestOptions.RegularPreview);
-            comp4.GetDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected1);
+            CompileAndVerify(comp4).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (3000,14): warning CS0105: The using directive for 'C2' appeared previously in this namespace
+                // using static C2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(3000, 14)
+                );
 
             var comp5 = CreateCompilation(new[] { source3 + source4 + source5, source6 }, parseOptions: TestOptions.RegularPreview);
-            comp5.GetDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected2);
+            CompileAndVerify(comp5).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,21): warning CS0105: The using directive for 'C2' appeared previously in this namespace
+                // global using static C2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(2000, 21),
+                // (3000,14): warning CS0105: The using directive for 'C2' appeared previously in this namespace
+                // using static C2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(3000, 14)
+                );
 
             var comp6 = CreateCompilation(new[] { source3, source4, source5, source6 }, parseOptions: TestOptions.RegularPreview);
-            comp6.GetDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected2);
+            CompileAndVerify(comp6).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,21): hidden CS8933: The using directive for 'C2' appeared previously as global using
+                // global using static C2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(2000, 21),
+                // (3000,14): hidden CS8933: The using directive for 'C2' appeared previously as global using
+                // using static C2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(3000, 14)
+                );
 
             var comp7 = CreateCompilation(new[] { source3 + source5, source4, source6 }, parseOptions: TestOptions.RegularPreview);
-            comp7.GetDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected2);
+            CompileAndVerify(comp7).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,21): hidden CS8933: The using directive for 'C2' appeared previously as global using
+                // global using static C2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(2000, 21),
+                // (3000,14): warning CS0105: The using directive for 'C2' appeared previously in this namespace
+                // using static C2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(3000, 14)
+                );
 
             var comp8 = CreateCompilation(new[] { source5, source3, source6 }, parseOptions: TestOptions.RegularPreview);
-            comp8.GetDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected1);
+            CompileAndVerify(comp8).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected1);
 
             var comp9 = CreateCompilation(new[] { source5, source3, source4, source6 }, parseOptions: TestOptions.RegularPreview);
-            comp9.GetDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected2);
+            CompileAndVerify(comp9).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,21): hidden CS8933: The using directive for 'C2' appeared previously as global using
+                // global using static C2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(2000, 21),
+                // (3000,14): hidden CS8933: The using directive for 'C2' appeared previously as global using
+                // using static C2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(3000, 14)
+                );
         }
 
         [Fact]
@@ -2593,16 +2634,16 @@ class C2 {}
 ";
             var comp2 = CreateCompilation(new[] { source2, source3 }, parseOptions: TestOptions.RegularPreview);
             comp2.GetSemanticModel(comp2.SyntaxTrees[1]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
-                // (2000,21): warning CS0105: The using directive for 'C2' appeared previously in this namespace
+                // (2000,21): hidden CS8933: The using directive for 'C2' appeared previously as global using
                 // global using static C2;
-                Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(2000, 21)
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(2000, 21)
                 );
 
             comp2 = CreateCompilation(new[] { source3, source2 }, parseOptions: TestOptions.RegularPreview);
             comp2.GetSemanticModel(comp2.SyntaxTrees[1]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
-                // (1000,21): warning CS0105: The using directive for 'C2' appeared previously in this namespace
+                // (1000,21): hidden CS8933: The using directive for 'C2' appeared previously as global using
                 // global using static C2;
-                Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(1000, 21)
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(1000, 21)
                 );
         }
 
@@ -2623,9 +2664,163 @@ class C2 {}
 
             var expected = new[]
             {
+                // (1000,14): hidden CS8933: The using directive for 'C2' appeared previously as global using
+                // using static C2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "C2").WithArguments("C2").WithLocation(1000, 14)
+            };
+
+            comp2.GetSemanticModel(comp2.SyntaxTrees[1]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected);
+
+            comp2 = CreateCompilation(new[] { source3, source2 }, parseOptions: TestOptions.RegularPreview);
+            comp2.GetSemanticModel(comp2.SyntaxTrees[0]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected);
+
+            comp2 = CreateCompilation(source2 + source3, parseOptions: TestOptions.RegularPreview);
+            comp2.GetSemanticModel(comp2.SyntaxTrees[0]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
                 // (1000,14): warning CS0105: The using directive for 'C2' appeared previously in this namespace
                 // using static C2;
                 Diagnostic(ErrorCode.WRN_DuplicateUsing, "C2").WithArguments("C2").WithLocation(1000, 14)
+                );
+        }
+
+        [Fact]
+        public void UsingConfictWithGlobalUsing_04()
+        {
+            var source3 = @"
+#line 1000
+global using N2;
+";
+            var source4 = @"
+#line 2000
+global using N2;
+";
+            var source5 = @"
+#line 3000
+using N2;
+";
+            var source6 = @"
+namespace N2 { class C2 {} }
+";
+            var comp2 = CreateCompilation(new[] { source3, source5, source6 }, parseOptions: TestOptions.RegularPreview);
+
+            var expected1 = new[]
+            {
+                // (3000,7): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(3000, 7)
+            };
+
+            CompileAndVerify(comp2).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected1);
+
+            var comp3 = CreateCompilation(new[] { source3 + source4, source5, source6 }, parseOptions: TestOptions.RegularPreview);
+
+            CompileAndVerify(comp3).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,14): warning CS0105: The using directive for 'N2' appeared previously in this namespace
+                // global using N2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "N2").WithArguments("N2").WithLocation(2000, 14),
+                // (3000,7): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(3000, 7)
+                );
+
+            var comp4 = CreateCompilation(new[] { source3 + source5, source6 }, parseOptions: TestOptions.RegularPreview);
+            CompileAndVerify(comp4).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (3000,7): warning CS0105: The using directive for 'N2' appeared previously in this namespace
+                // using N2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "N2").WithArguments("N2").WithLocation(3000, 7)
+                );
+
+            var comp5 = CreateCompilation(new[] { source3 + source4 + source5, source6 }, parseOptions: TestOptions.RegularPreview);
+            CompileAndVerify(comp5).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,14): warning CS0105: The using directive for 'N2' appeared previously in this namespace
+                // global using N2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "N2").WithArguments("N2").WithLocation(2000, 14),
+                // (3000,7): warning CS0105: The using directive for 'N2' appeared previously in this namespace
+                // using N2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "N2").WithArguments("N2").WithLocation(3000, 7)
+                );
+
+            var comp6 = CreateCompilation(new[] { source3, source4, source5, source6 }, parseOptions: TestOptions.RegularPreview);
+            CompileAndVerify(comp6).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,14): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // global using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(2000, 14),
+                // (3000,7): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(3000, 7)
+                );
+
+            var comp7 = CreateCompilation(new[] { source3 + source5, source4, source6 }, parseOptions: TestOptions.RegularPreview);
+            CompileAndVerify(comp7).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,14): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // global using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(2000, 14),
+                // (3000,7): warning CS0105: The using directive for 'N2' appeared previously in this namespace
+                // using N2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "N2").WithArguments("N2").WithLocation(3000, 7)
+                );
+
+            var comp8 = CreateCompilation(new[] { source5, source3, source6 }, parseOptions: TestOptions.RegularPreview);
+            CompileAndVerify(comp8).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected1);
+
+            var comp9 = CreateCompilation(new[] { source5, source3, source4, source6 }, parseOptions: TestOptions.RegularPreview);
+            CompileAndVerify(comp9).Diagnostics.Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,14): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // global using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(2000, 14),
+                // (3000,7): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(3000, 7)
+                );
+        }
+
+        [Fact]
+        public void UsingConfictWithGlobalUsing_05()
+        {
+            var source2 = @"
+#line 1000
+global using N2;
+";
+            var source3 = @"
+#line 2000
+global using N2;
+
+namespace N2 { class C2 {} }
+";
+            var comp2 = CreateCompilation(new[] { source2, source3 }, parseOptions: TestOptions.RegularPreview);
+            comp2.GetSemanticModel(comp2.SyntaxTrees[1]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (2000,14): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // global using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(2000, 14)
+                );
+
+            comp2 = CreateCompilation(new[] { source3, source2 }, parseOptions: TestOptions.RegularPreview);
+            comp2.GetSemanticModel(comp2.SyntaxTrees[1]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (1000,14): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // global using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(1000, 14)
+                );
+        }
+
+        [Fact]
+        public void UsingConfictWithGlobalUsing_06()
+        {
+            var source2 = @"
+global using N2;
+";
+            var source3 = @"
+#line 1000
+using N2;
+#line default
+
+namespace N2 { class C2 {} }
+";
+            var comp2 = CreateCompilation(new[] { source2, source3 }, parseOptions: TestOptions.RegularPreview);
+
+            var expected = new[]
+            {
+                // (1000,7): hidden CS8933: The using directive for 'N2' appeared previously as global using
+                // using N2;
+                Diagnostic(ErrorCode.HDN_DuplicateWithGlobalUsing, "N2").WithArguments("N2").WithLocation(1000, 7)
             };
 
             comp2.GetSemanticModel(comp2.SyntaxTrees[1]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected);
@@ -2634,7 +2829,11 @@ class C2 {}
             comp2.GetSemanticModel(comp2.SyntaxTrees[0]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected);
 
             comp2 = CreateCompilation(source2 + source3, parseOptions: TestOptions.RegularPreview);
-            comp2.GetSemanticModel(comp2.SyntaxTrees[0]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(expected);
+            comp2.GetSemanticModel(comp2.SyntaxTrees[0]).GetDeclarationDiagnostics().Where(d => d.Code != (int)ErrorCode.HDN_UnusedUsingDirective).Verify(
+                // (1000,7): warning CS0105: The using directive for 'N2' appeared previously in this namespace
+                // using N2;
+                Diagnostic(ErrorCode.WRN_DuplicateUsing, "N2").WithArguments("N2").WithLocation(1000, 7)
+                );
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitObjectCreationTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitObjectCreationTests.cs
index 263f11dfc8515..5dbf18fc098b7 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitObjectCreationTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitObjectCreationTests.cs
@@ -4659,5 +4659,29 @@ public C(C c) {}
                 Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "new()").WithArguments("c", "C.C(C)").WithLocation(2, 4)
                 );
         }
+
+        [Fact, WorkItem(54193, "https://github.com/dotnet/roslyn/issues/54193")]
+        public void InSwitchExpression()
+        {
+            var source = @"
+using static System.Console;
+
+var c0 = 0 switch { 1 => new C(), int n => new() { n = n } };
+C c1 = 1 switch { int n => new() { n = n } };
+C c2 = 2 switch { int n => n switch { int u => new() { n = n + u } } };
+
+Write(c0.n);
+Write(c1.n);
+Write(c2.n);
+
+class C 
+{
+    public int n;
+}
+";
+            var compilation = CreateCompilation(source);
+            CompileAndVerify(compilation, expectedOutput: "014")
+                .VerifyDiagnostics();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/InheritanceBindingTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/InheritanceBindingTests.cs
index 46544f147fa73..a303513dcc29e 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/InheritanceBindingTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/InheritanceBindingTests.cs
@@ -68,7 +68,7 @@ static void IGoo.Method12() { }
     private protected void IGoo.Method14() { }
 }";
 
-            CreateCompilation(text).VerifyDiagnostics(
+            CreateCompilation(text, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
                 // (22,24): error CS0106: The modifier 'abstract' is not valid for this item
                 //     abstract void IGoo.Method1() { }
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "Method1").WithArguments("abstract").WithLocation(22, 24),
@@ -99,15 +99,21 @@ private protected void IGoo.Method14() { }
                 // (34,23): error CS0106: The modifier 'private' is not valid for this item
                 //     private void IGoo.Method10() { }
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "Method10").WithArguments("private").WithLocation(34, 23),
-                // (37,22): error CS0106: The modifier 'static' is not valid for this item
+                // (37,22): error CS8703: The modifier 'static' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     static void IGoo.Method12() { }
-                Diagnostic(ErrorCode.ERR_BadMemberFlag, "Method12").WithArguments("static").WithLocation(37, 22),
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "Method12").WithArguments("static", "9.0", "preview").WithLocation(37, 22),
                 // (40,33): error CS0106: The modifier 'private protected' is not valid for this item
                 //     private protected void IGoo.Method14() { }
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "Method14").WithArguments("private protected").WithLocation(40, 33),
+                // (37,22): error CS0539: 'AbstractGoo.Method12()' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static void IGoo.Method12() { }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "Method12").WithArguments("AbstractGoo.Method12()").WithLocation(37, 22),
                 // (38,23): error CS0754: A partial method may not explicitly implement an interface method
                 //     partial void IGoo.Method13();
                 Diagnostic(ErrorCode.ERR_PartialMethodNotExplicit, "Method13").WithLocation(38, 23),
+                // (20,38): error CS0535: 'AbstractGoo' does not implement interface member 'IGoo.Method12()'
+                // abstract partial class AbstractGoo : IGoo
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "IGoo").WithArguments("AbstractGoo", "IGoo.Method12()").WithLocation(20, 38),
                 // (36,22): warning CS0626: Method, operator, or accessor 'AbstractGoo.IGoo.Method11()' is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation.
                 //     extern void IGoo.Method11(); //not an error (in dev10 or roslyn)
                 Diagnostic(ErrorCode.WRN_ExternMethodNoImplementation, "Method11").WithArguments("AbstractGoo.IGoo.Method11()").WithLocation(36, 22)
@@ -154,7 +160,7 @@ private int IGoo.Property10 { set { } }
     static int IGoo.Property12 { set { } }
 }";
 
-            CreateCompilation(text).VerifyDiagnostics(
+            CreateCompilation(text, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
                 // (20,23): error CS0106: The modifier 'abstract' is not valid for this item
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "Property1").WithArguments("abstract"),
                 // (21,22): error CS0106: The modifier 'virtual' is not valid for this item
@@ -175,8 +181,15 @@ static int IGoo.Property12 { set { } }
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "Property9").WithArguments("protected internal"),
                 // (32,22): error CS0106: The modifier 'private' is not valid for this item
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "Property10").WithArguments("private"),
-                // (35,21): error CS0106: The modifier 'static' is not valid for this item
-                Diagnostic(ErrorCode.ERR_BadMemberFlag, "Property12").WithArguments("static"),
+                // (35,21): error CS8703: The modifier 'static' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     static int IGoo.Property12 { set { } }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "Property12").WithArguments("static", "9.0", "preview").WithLocation(35, 21),
+                // (35,21): error CS0539: 'AbstractGoo.Property12' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static int IGoo.Property12 { set { } }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "Property12").WithArguments("AbstractGoo.Property12").WithLocation(35, 21),
+                // (18,30): error CS0535: 'AbstractGoo' does not implement interface member 'IGoo.Property12'
+                // abstract class AbstractGoo : IGoo
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "IGoo").WithArguments("AbstractGoo", "IGoo.Property12").WithLocation(18, 30),
                 // (34,34): warning CS0626: Method, operator, or accessor 'AbstractGoo.IGoo.Property11.set' is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation.
                 Diagnostic(ErrorCode.WRN_ExternMethodNoImplementation, "set").WithArguments("AbstractGoo.IGoo.Property11.set"));
         }
@@ -292,7 +305,7 @@ static event System.Action IGoo.Event12 { add { } remove { } }
             // If the other errors are fixed ERR_ExternHasBody is reported. 
             // We report all errors at once since they are unrelated, not cascading.
 
-            CreateCompilation(text).VerifyDiagnostics(
+            CreateCompilation(text, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
                 // (20,39): error CS0106: The modifier 'abstract' is not valid for this item
                 //     abstract event System.Action IGoo.Event1 { add { } remove { } }
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "Event1").WithArguments("abstract"),
@@ -329,9 +342,16 @@ static event System.Action IGoo.Event12 { add { } remove { } }
                 // (34,55): error CS0179: 'AbstractGoo.IGoo.Event11.remove' cannot be extern and declare a body
                 //     extern event System.Action IGoo.Event11 { add { } remove { } }
                 Diagnostic(ErrorCode.ERR_ExternHasBody, "remove").WithArguments("AbstractGoo.IGoo.Event11.remove"),
-                // (35,37): error CS0106: The modifier 'static' is not valid for this item
+                // (35,37): error CS8703: The modifier 'static' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     static event System.Action IGoo.Event12 { add { } remove { } }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "Event12").WithArguments("static", "9.0", "preview").WithLocation(35, 37),
+                // (35,37): error CS0539: 'AbstractGoo.Event12' in explicit interface declaration is not found among members of the interface that can be implemented
                 //     static event System.Action IGoo.Event12 { add { } remove { } }
-                Diagnostic(ErrorCode.ERR_BadMemberFlag, "Event12").WithArguments("static"));
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "Event12").WithArguments("AbstractGoo.Event12").WithLocation(35, 37),
+                // (18,30): error CS0535: 'AbstractGoo' does not implement interface member 'IGoo.Event12'
+                // abstract class AbstractGoo : IGoo
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "IGoo").WithArguments("AbstractGoo", "IGoo.Event12").WithLocation(18, 30)
+                );
         }
 
         [Fact] // can't bind to events
@@ -3688,7 +3708,7 @@ protected internal void Method6() { }
                 // (13,22): error CS0737: 'Base' does not implement interface member 'Interface.Method6()'. 'Base.Method6()' cannot implement an interface member because it is not public.
                 // partial class Base : Interface
                 Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "Interface").WithArguments("Base", "Interface.Method6()", "Base.Method6()").WithLocation(13, 22),
-                // (13,22): error CS0736: 'Base' does not implement interface member 'Interface.Method1()'. 'Base.Method1()' cannot implement an interface member because it is static.
+                // (13,22): error CS0736: 'Base' does not implement instance interface member 'Interface.Method1()'. 'Base.Method1()' cannot implement the interface member because it is static.
                 // partial class Base : Interface
                 Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "Interface").WithArguments("Base", "Interface.Method1()", "Base.Method1()").WithLocation(13, 22));
         }
@@ -4773,6 +4793,16 @@ public void Method(T i) { }
 public class Derived : Base<int>, Interface<int, int>
 {
 }
+
+class Other : Interface<int, int>
+{
+    void Interface<int, int>.Method(int i) { }
+}
+
+class YetAnother : Interface<int, int>
+{
+    public void Method(int i) { }
+}
 ";
             //Both Base methods implement Interface.Method(int)
             //Both Base methods implement Interface.Method(T)
@@ -4786,7 +4816,16 @@ public class Derived : Base<int>, Interface<int, int>
                 Diagnostic(ErrorCode.WRN_MultipleRuntimeImplementationMatches, "Interface<int, int>").WithArguments("Base<int>.Method(int)", "Interface<int, int>.Method(int)", "Derived").WithLocation(15, 35),
                 // (15,35): warning CS1956: Member 'Base<int>.Method(int)' implements interface member 'Interface<int, int>.Method(int)' in type 'Derived'. There are multiple matches for the interface member at run-time. It is implementation dependent which method will be called.
                 // public class Derived : Base<int>, Interface<int, int>
-                Diagnostic(ErrorCode.WRN_MultipleRuntimeImplementationMatches, "Interface<int, int>").WithArguments("Base<int>.Method(int)", "Interface<int, int>.Method(int)", "Derived").WithLocation(15, 35)
+                Diagnostic(ErrorCode.WRN_MultipleRuntimeImplementationMatches, "Interface<int, int>").WithArguments("Base<int>.Method(int)", "Interface<int, int>.Method(int)", "Derived").WithLocation(15, 35),
+                // (19,15): error CS0535: 'Other' does not implement interface member 'Interface<int, int>.Method(int)'
+                // class Other : Interface<int, int>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "Interface<int, int>").WithArguments("Other", "Interface<int, int>.Method(int)").WithLocation(19, 15),
+                // (19,15): error CS0535: 'Other' does not implement interface member 'Interface<int, int>.Method(int)'
+                // class Other : Interface<int, int>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "Interface<int, int>").WithArguments("Other", "Interface<int, int>.Method(int)").WithLocation(19, 15),
+                // (21,30): warning CS0473: Explicit interface implementation 'Other.Interface<int, int>.Method(int)' matches more than one interface member. Which interface member is actually chosen is implementation-dependent. Consider using a non-explicit implementation instead.
+                //     void Interface<int, int>.Method(int i) { }
+                Diagnostic(ErrorCode.WRN_ExplicitImplCollision, "Method").WithArguments("Other.Interface<int, int>.Method(int)").WithLocation(21, 30)
                 );
         }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaDiscardParametersTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaDiscardParametersTests.cs
index 76a4850e08ab8..5fc1d4f4ef61c 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaDiscardParametersTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaDiscardParametersTests.cs
@@ -368,15 +368,15 @@ static void Main()
 
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (8,14): error CS8652: The feature 'lambda attributes' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (8,14): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         a = ([A] _, y) => { };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "[A]").WithArguments("lambda attributes").WithLocation(8, 14),
-                // (9,24): error CS8652: The feature 'lambda attributes' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[A]").WithArguments("lambda attributes", "10.0").WithLocation(8, 14),
+                // (9,24): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         a = (object x, [A] object _) => { };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "[A]").WithArguments("lambda attributes").WithLocation(9, 24));
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[A]").WithArguments("lambda attributes", "10.0").WithLocation(9, 24));
             verifyAttributes(comp);
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics();
             verifyAttributes(comp);
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs
index c73417b967423..19801f4bafc0b 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs
@@ -3537,7 +3537,7 @@ static void Main()
     }
 }";
 
-            var comp = CreateCompilation(new[] { sourceA, sourceB }, parseOptions: TestOptions.RegularPreview, options: TestOptions.ReleaseExe);
+            var comp = CreateCompilation(new[] { sourceA, sourceB }, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseExe);
             var tree = comp.SyntaxTrees[0];
             var model = comp.GetSemanticModel(tree);
             var exprs = tree.GetRoot().DescendantNodes().OfType<LambdaExpressionSyntax>();
@@ -3607,23 +3607,23 @@ static void Main()
 
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (9,13): error CS8652: The feature 'lambda attributes' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (9,13): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         a = [A, B] (x, y) => { };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "[A, B]").WithArguments("lambda attributes").WithLocation(9, 13),
-                // (10,14): error CS8652: The feature 'lambda attributes' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[A, B]").WithArguments("lambda attributes", "10.0").WithLocation(9, 13),
+                // (10,14): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         a = ([A] x, [B] y) => { };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "[A]").WithArguments("lambda attributes").WithLocation(10, 14),
-                // (10,21): error CS8652: The feature 'lambda attributes' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[A]").WithArguments("lambda attributes", "10.0").WithLocation(10, 14),
+                // (10,21): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         a = ([A] x, [B] y) => { };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "[B]").WithArguments("lambda attributes").WithLocation(10, 21),
-                // (11,24): error CS8652: The feature 'lambda attributes' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[B]").WithArguments("lambda attributes", "10.0").WithLocation(10, 21),
+                // (11,24): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         a = (object x, [A][B] object y) => { };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "[A]").WithArguments("lambda attributes").WithLocation(11, 24),
-                // (11,27): error CS8652: The feature 'lambda attributes' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[A]").WithArguments("lambda attributes", "10.0").WithLocation(11, 24),
+                // (11,27): error CS8773: Feature 'lambda attributes' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         a = (object x, [A][B] object y) => { };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "[B]").WithArguments("lambda attributes").WithLocation(11, 27));
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "[B]").WithArguments("lambda attributes", "10.0").WithLocation(11, 27));
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics();
         }
 
@@ -3662,7 +3662,7 @@ static void Main()
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(expectedDiagnostics);
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics(expectedDiagnostics);
         }
 
@@ -4215,7 +4215,7 @@ static void Main()
 }";
             var comp = CreateCompilation(new[] { source, UnmanagedCallersOnlyAttributeDefinition }, parseOptions: TestOptions.RegularPreview);
             comp.VerifyDiagnostics(
-                // (7,21): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions.
+                // (7,21): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
                 //         Action a = [UnmanagedCallersOnly] static () => { };
                 Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(7, 21));
         }
@@ -4329,6 +4329,837 @@ static void Main()
             Assert.Equal(FlowAnalysisAnnotations.NotNullWhenTrue, lambda.Parameters[0].FlowAnalysisAnnotations);
         }
 
+        [Fact]
+        public void LambdaReturnType_01()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F<T>()
+    {
+        Func<T> f1 = T () => default;
+        Func<T, T> f2 = T (x) => { return x; };
+        Func<T, T> f3 = T (T x) => x;
+    }
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (6,22): error CS8773: Feature 'lambda return type' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //         Func<T> f1 = T () => default;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "T").WithArguments("lambda return type", "10.0").WithLocation(6, 22),
+                // (7,25): error CS8773: Feature 'lambda return type' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //         Func<T, T> f2 = T (x) => { return x; };
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "T").WithArguments("lambda return type", "10.0").WithLocation(7, 25),
+                // (8,25): error CS8773: Feature 'lambda return type' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //         Func<T, T> f3 = T (T x) => x;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "T").WithArguments("lambda return type", "10.0").WithLocation(8, 25));
+
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
+            comp.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void LambdaReturnType_02()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F<T, U>()
+    {
+        Func<T> f1;
+        Func<U> f2;
+        f1 = T () => default;
+        f2 = T () => default;
+        f1 = U () => default;
+        f2 = U () => default;
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (9,14): error CS8934: Cannot convert lambda expression to type 'Func<U>' because the return type does not match the delegate return type
+                //         f2 = T () => default;
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "T () => default").WithArguments("lambda expression", "System.Func<U>").WithLocation(9, 14),
+                // (10,14): error CS8934: Cannot convert lambda expression to type 'Func<T>' because the return type does not match the delegate return type
+                //         f1 = U () => default;
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "U () => default").WithArguments("lambda expression", "System.Func<T>").WithLocation(10, 14));
+        }
+
+        [Fact]
+        public void LambdaReturnType_03()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F<T, U>() where U : T
+    {
+        Func<T> f1;
+        Func<U> f2;
+        f1 = T () => default;
+        f2 = T () => default;
+        f1 = U () => default;
+        f2 = U () => default;
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (9,14): error CS8934: Cannot convert lambda expression to type 'Func<U>' because the return type does not match the delegate return type
+                //         f2 = T () => default;
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "T () => default").WithArguments("lambda expression", "System.Func<U>").WithLocation(9, 14),
+                // (10,14): error CS8934: Cannot convert lambda expression to type 'Func<T>' because the return type does not match the delegate return type
+                //         f1 = U () => default;
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "U () => default").WithArguments("lambda expression", "System.Func<T>").WithLocation(10, 14));
+        }
+
+        [Fact]
+        public void LambdaReturnType_04()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void F<T, U>()
+    {
+        Expression<Func<T>> e1;
+        Expression<Func<U>> e2;
+        e1 = T () => default;
+        e2 = T () => default;
+        e1 = U () => default;
+        e2 = U () => default;
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (10,14): error CS8934: Cannot convert lambda expression to type 'Expression<Func<U>>' because the return type does not match the delegate return type
+                //         e2 = T () => default;
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "T () => default").WithArguments("lambda expression", "System.Linq.Expressions.Expression<System.Func<U>>").WithLocation(10, 14),
+                // (11,14): error CS8934: Cannot convert lambda expression to type 'Expression<Func<T>>' because the return type does not match the delegate return type
+                //         e1 = U () => default;
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "U () => default").WithArguments("lambda expression", "System.Linq.Expressions.Expression<System.Func<T>>").WithLocation(11, 14));
+        }
+
+        [Fact]
+        public void LambdaReturnType_05()
+        {
+            var source =
+@"#nullable enable
+using System;
+class Program
+{
+    static void Main()
+    {
+        Func<dynamic> f1 = object () => default!;
+        Func<(int, int)> f2 = (int X, int Y) () => default;
+        Func<string?> f3 = string () => default!;
+        Func<IntPtr> f4 = nint () => default;
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (9,28): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'Func<string?>' (possibly because of nullability attributes).
+                //         Func<string?> f3 = string () => default!;
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "string () => default!").WithArguments("lambda expression", "System.Func<string?>").WithLocation(9, 28));
+        }
+
+        [Fact]
+        public void LambdaReturnType_06()
+        {
+            var source =
+@"#nullable enable
+using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void Main()
+    {
+        Expression<Func<object>> e1 = dynamic () => default!;
+        Expression<Func<(int X, int Y)>> e2 = (int, int) () => default;
+        Expression<Func<string>> e3 = string? () => default;
+        Expression<Func<nint>> e4 = IntPtr () => default;
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (10,39): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'Func<string>' (possibly because of nullability attributes).
+                //         Expression<Func<string>> e3 = string? () => default;
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "string? () => default").WithArguments("lambda expression", "System.Func<string>").WithLocation(10, 39));
+        }
+
+        [Fact]
+        public void LambdaReturnType_07()
+        {
+            var source =
+@"#nullable enable
+using System;
+struct S<T> { }
+class Program
+{
+    static void Main()
+    {
+        Delegate d1 = string? () => default;
+        Delegate d2 = string () => default;
+        Delegate d3 = S<object?> () => default(S<object?>);
+        Delegate d4 = S<object?> () => default(S<object>);
+        Delegate d5 = S<object> () => default(S<object?>);
+        Delegate d6 = S<object> () => default(S<object>);
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (9,36): warning CS8603: Possible null reference return.
+                //         Delegate d2 = string () => default;
+                Diagnostic(ErrorCode.WRN_NullReferenceReturn, "default").WithLocation(9, 36),
+                // (11,40): warning CS8619: Nullability of reference types in value of type 'S<object>' doesn't match target type 'S<object?>'.
+                //         Delegate d4 = S<object?> () => default(S<object>);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "default(S<object>)").WithArguments("S<object>", "S<object?>").WithLocation(11, 40),
+                // (12,39): warning CS8619: Nullability of reference types in value of type 'S<object?>' doesn't match target type 'S<object>'.
+                //         Delegate d5 = S<object> () => default(S<object?>);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "default(S<object?>)").WithArguments("S<object?>", "S<object>").WithLocation(12, 39));
+        }
+
+        [Fact]
+        public void LambdaReturnType_08()
+        {
+            var source =
+@"#nullable enable
+using System;
+struct S<T> { }
+class Program
+{
+    static void Main()
+    {
+        Func<string?> f1 = string? () => throw null!;
+        Func<string?> f2 = string () => throw null!;
+        Func<string> f3 = string? () => throw null!;
+        Func<string> f4 = string () => throw null!;
+        Func<S<object?>> f5 = S<object?> () => throw null!;
+        Func<S<object?>> f6 = S<object> () => throw null!;
+        Func<S<object>> f7 = S<object?> () => throw null!;
+        Func<S<object>> f8 = S<object> () => throw null!;
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (9,28): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'Func<string?>' (possibly because of nullability attributes).
+                //         Func<string?> f2 = string () => throw null!;
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "string () => throw null!").WithArguments("lambda expression", "System.Func<string?>").WithLocation(9, 28),
+                // (10,27): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'Func<string>' (possibly because of nullability attributes).
+                //         Func<string> f3 = string? () => throw null!;
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "string? () => throw null!").WithArguments("lambda expression", "System.Func<string>").WithLocation(10, 27),
+                // (13,31): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'Func<S<object?>>' (possibly because of nullability attributes).
+                //         Func<S<object?>> f6 = S<object> () => throw null!;
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "S<object> () => throw null!").WithArguments("lambda expression", "System.Func<S<object?>>").WithLocation(13, 31),
+                // (14,30): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'Func<S<object>>' (possibly because of nullability attributes).
+                //         Func<S<object>> f7 = S<object?> () => throw null!;
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "S<object?> () => throw null!").WithArguments("lambda expression", "System.Func<S<object>>").WithLocation(14, 30));
+        }
+
+        [Fact]
+        public void LambdaReturnType_09()
+        {
+            var source =
+@"#nullable enable
+struct S<T> { }
+delegate ref T D1<T>();
+delegate ref readonly T D2<T>();
+class Program
+{
+    static void Main()
+    {
+        D1<S<object?>> f1 = (ref S<object?> () => throw null!);
+        D1<S<object?>> f2 = (ref S<object> () => throw null!);
+        D1<S<object>> f3 = (ref S<object?> () => throw null!);
+        D1<S<object>> f4 = (ref S<object> () => throw null!);
+        D2<S<object?>> f5 = (ref readonly S<object?> () => throw null!);
+        D2<S<object?>> f6 = (ref readonly S<object> () => throw null!);
+        D2<S<object>> f7 = (ref readonly S<object?> () => throw null!);
+        D2<S<object>> f8 = (ref readonly S<object> () => throw null!);
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (10,30): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'D1<S<object?>>' (possibly because of nullability attributes).
+                //         D1<S<object?>> f2 = (ref S<object> () => throw null!);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "ref S<object> () => throw null!").WithArguments("lambda expression", "D1<S<object?>>").WithLocation(10, 30),
+                // (11,29): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'D1<S<object>>' (possibly because of nullability attributes).
+                //         D1<S<object>> f3 = (ref S<object?> () => throw null!);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "ref S<object?> () => throw null!").WithArguments("lambda expression", "D1<S<object>>").WithLocation(11, 29),
+                // (14,30): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'D2<S<object?>>' (possibly because of nullability attributes).
+                //         D2<S<object?>> f6 = (ref readonly S<object> () => throw null!);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "ref readonly S<object> () => throw null!").WithArguments("lambda expression", "D2<S<object?>>").WithLocation(14, 30),
+                // (15,29): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'D2<S<object>>' (possibly because of nullability attributes).
+                //         D2<S<object>> f7 = (ref readonly S<object?> () => throw null!);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "ref readonly S<object?> () => throw null!").WithArguments("lambda expression", "D2<S<object>>").WithLocation(15, 29));
+        }
+
+        [Fact]
+        public void LambdaReturnType_10()
+        {
+            var source =
+@"delegate T D1<T>(ref T t);
+delegate ref T D2<T>(ref T t);
+delegate ref readonly T D3<T>(ref T t);
+class Program
+{
+    static void F<T>()
+    {
+        D1<T> d1;
+        D2<T> d2;
+        D3<T> d3;
+        d1 = T (ref T t) => t;
+        d2 = T (ref T t) => t;
+        d3 = T (ref T t) => t;
+        d1 = (ref T (ref T t) => ref t);
+        d2 = (ref T (ref T t) => ref t);
+        d3 = (ref T (ref T t) => ref t);
+        d1 = (ref readonly T (ref T t) => ref t);
+        d2 = (ref readonly T (ref T t) => ref t);
+        d3 = (ref readonly T (ref T t) => ref t);
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (12,14): error CS8934: Cannot convert lambda expression to type 'D2<T>' because the return type does not match the delegate return type
+                //         d2 = T (ref T t) => t;
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "T (ref T t) => t").WithArguments("lambda expression", "D2<T>").WithLocation(12, 14),
+                // (13,14): error CS8934: Cannot convert lambda expression to type 'D3<T>' because the return type does not match the delegate return type
+                //         d3 = T (ref T t) => t;
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "T (ref T t) => t").WithArguments("lambda expression", "D3<T>").WithLocation(13, 14),
+                // (14,15): error CS8934: Cannot convert lambda expression to type 'D1<T>' because the return type does not match the delegate return type
+                //         d1 = (ref T (ref T t) => ref t);
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "ref T (ref T t) => ref t").WithArguments("lambda expression", "D1<T>").WithLocation(14, 15),
+                // (16,15): error CS8934: Cannot convert lambda expression to type 'D3<T>' because the return type does not match the delegate return type
+                //         d3 = (ref T (ref T t) => ref t);
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "ref T (ref T t) => ref t").WithArguments("lambda expression", "D3<T>").WithLocation(16, 15),
+                // (17,15): error CS8934: Cannot convert lambda expression to type 'D1<T>' because the return type does not match the delegate return type
+                //         d1 = (ref readonly T (ref T t) => ref t);
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "ref readonly T (ref T t) => ref t").WithArguments("lambda expression", "D1<T>").WithLocation(17, 15),
+                // (18,15): error CS8934: Cannot convert lambda expression to type 'D2<T>' because the return type does not match the delegate return type
+                //         d2 = (ref readonly T (ref T t) => ref t);
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "ref readonly T (ref T t) => ref t").WithArguments("lambda expression", "D2<T>").WithLocation(18, 15));
+        }
+
+        [Fact]
+        public void LambdaReturnType_11()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Delegate d;
+        d = (ref void () => { });
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (7,14): error CS8917: The delegate type could not be inferred.
+                //         d = (ref void () => { });
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "ref void () => { }").WithLocation(7, 14),
+                // (7,18): error CS1547: Keyword 'void' cannot be used in this context
+                //         d = (ref void () => { });
+                Diagnostic(ErrorCode.ERR_NoVoidHere, "void").WithLocation(7, 18));
+        }
+
+        [ConditionalFact(typeof(DesktopOnly))]
+        public void LambdaReturnType_12()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Delegate d;
+        d = TypedReference () => throw null;
+        d = RuntimeArgumentHandle () => throw null;
+        d = ArgIterator () => throw null;
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (7,13): error CS1599: The return type of a method, delegate, or function pointer cannot be 'TypedReference'
+                //         d = TypedReference () => throw null;
+                Diagnostic(ErrorCode.ERR_MethodReturnCantBeRefAny, "TypedReference").WithArguments("System.TypedReference").WithLocation(7, 13),
+                // (7,13): error CS8917: The delegate type could not be inferred.
+                //         d = TypedReference () => throw null;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "TypedReference () => throw null").WithLocation(7, 13),
+                // (8,13): error CS1599: The return type of a method, delegate, or function pointer cannot be 'RuntimeArgumentHandle'
+                //         d = RuntimeArgumentHandle () => throw null;
+                Diagnostic(ErrorCode.ERR_MethodReturnCantBeRefAny, "RuntimeArgumentHandle").WithArguments("System.RuntimeArgumentHandle").WithLocation(8, 13),
+                // (8,13): error CS8917: The delegate type could not be inferred.
+                //         d = RuntimeArgumentHandle () => throw null;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "RuntimeArgumentHandle () => throw null").WithLocation(8, 13),
+                // (9,13): error CS1599: The return type of a method, delegate, or function pointer cannot be 'ArgIterator'
+                //         d = ArgIterator () => throw null;
+                Diagnostic(ErrorCode.ERR_MethodReturnCantBeRefAny, "ArgIterator").WithArguments("System.ArgIterator").WithLocation(9, 13),
+                // (9,13): error CS8917: The delegate type could not be inferred.
+                //         d = ArgIterator () => throw null;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "ArgIterator () => throw null").WithLocation(9, 13));
+        }
+
+        [Fact]
+        public void LambdaReturnType_13()
+        {
+            var source =
+@"static class S { }
+delegate S D();
+class Program
+{
+    static void Main()
+    {
+        D d = S () => default;
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (7,15): error CS0722: 'S': static types cannot be used as return types
+                //         D d = S () => default;
+                Diagnostic(ErrorCode.ERR_ReturnTypeIsStaticClass, "S").WithArguments("S").WithLocation(7, 15));
+        }
+
+        [Fact]
+        public void LambdaReturnType_14()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Delegate d = async int () => 0;
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (6,35): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T>
+                //         Delegate d = async int () => 0;
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "=>").WithLocation(6, 35),
+                // (6,35): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
+                //         Delegate d = async int () => 0;
+                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "=>").WithLocation(6, 35));
+        }
+
+        [Fact]
+        public void LambdaReturnType_15()
+        {
+            var source =
+@"using System;
+using System.Threading.Tasks;
+delegate ref Task D(string s);
+class Program
+{
+    static void Main()
+    {
+        Delegate d1 = async ref Task (s) => { _ = s.Length; await Task.Yield(); };
+        D d2 = async ref Task (s) => { _ = s.Length; await Task.Yield(); };
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (8,23): error CS8917: The delegate type could not be inferred.
+                //         Delegate d1 = async ref Task (s) => { _ = s.Length; await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "async ref Task (s) => { _ = s.Length; await Task.Yield(); }").WithLocation(8, 23),
+                // (8,29): error CS1073: Unexpected token 'ref'
+                //         Delegate d1 = async ref Task (s) => { _ = s.Length; await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "ref").WithArguments("ref").WithLocation(8, 29),
+                // (9,22): error CS1073: Unexpected token 'ref'
+                //         D d2 = async ref Task (s) => { _ = s.Length; await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "ref").WithArguments("ref").WithLocation(9, 22));
+        }
+
+        [Fact]
+        public void LambdaReturnType_16()
+        {
+            var source =
+@"using System;
+using System.Threading.Tasks;
+delegate ref Task D(string s);
+class Program
+{
+    static void Main()
+    {
+        Delegate d1 = async ref Task (string s) => { _ = s.Length; await Task.Yield(); };
+        D d2 = async ref Task (string s) => { _ = s.Length; await Task.Yield(); };
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (8,23): error CS8917: The delegate type could not be inferred.
+                //         Delegate d1 = async ref Task (string s) => { _ = s.Length; await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "async ref Task (string s) => { _ = s.Length; await Task.Yield(); }").WithLocation(8, 23),
+                // (8,29): error CS1073: Unexpected token 'ref'
+                //         Delegate d1 = async ref Task (string s) => { _ = s.Length; await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "ref").WithArguments("ref").WithLocation(8, 29),
+                // (9,22): error CS1073: Unexpected token 'ref'
+                //         D d2 = async ref Task (string s) => { _ = s.Length; await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "ref").WithArguments("ref").WithLocation(9, 22));
+        }
+
+        [Fact]
+        public void LambdaReturnType_17()
+        {
+            var source =
+@"#nullable enable
+using System;
+class Program
+{
+    static void F(string? x, string y)
+    {
+        Func<string?> f1 = string () => { if (x is null) return x; return y; };
+        Func<string> f2 = string? () => { if (x is not null) return x; return y; };
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (7,28): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'Func<string?>' (possibly because of nullability attributes).
+                //         Func<string?> f1 = string () => { if (x is null) return x; return y; };
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "string () => { if (x is null) return x; return y; }").WithArguments("lambda expression", "System.Func<string?>").WithLocation(7, 28),
+                // (7,65): warning CS8603: Possible null reference return.
+                //         Func<string?> f1 = string () => { if (x is null) return x; return y; };
+                Diagnostic(ErrorCode.WRN_NullReferenceReturn, "x").WithLocation(7, 65),
+                // (8,27): warning CS8621: Nullability of reference types in return type of 'lambda expression' doesn't match the target delegate 'Func<string>' (possibly because of nullability attributes).
+                //         Func<string> f2 = string? () => { if (x is not null) return x; return y; };
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "string? () => { if (x is not null) return x; return y; }").WithArguments("lambda expression", "System.Func<string>").WithLocation(8, 27));
+        }
+
+        [Fact]
+        public void LambdaReturnType_CustomModifiers_01()
+        {
+            var sourceA =
+@".class public auto ansi sealed D extends [mscorlib]System.MulticastDelegate
+{
+    .method public hidebysig specialname rtspecialname instance void .ctor (object 'object', native int 'method') runtime managed { }
+    .method public hidebysig newslot virtual instance int32 modopt([mscorlib]System.Int16) Invoke () runtime managed { }
+    .method public hidebysig newslot virtual instance class [mscorlib]System.IAsyncResult BeginInvoke (class [mscorlib]System.AsyncCallback callback, object 'object') runtime managed { }
+    .method public hidebysig newslot virtual instance int32 modopt([mscorlib]System.Int16) EndInvoke (class [mscorlib]System.IAsyncResult result) runtime managed { }
+}";
+            var refA = CompileIL(sourceA);
+
+            var sourceB =
+@"class Program
+{
+    static void F(D d)
+    {
+        System.Console.WriteLine(d());
+    }
+    static void Main()
+    {
+        F(() => 1);
+        F(int () => 2);
+    }
+}";
+            CompileAndVerify(sourceB, references: new[] { refA }, parseOptions: TestOptions.RegularPreview, expectedOutput:
+@"1
+2");
+        }
+
+        [Fact]
+        public void LambdaReturnType_CustomModifiers_02()
+        {
+            var sourceA =
+@".class public auto ansi sealed D extends [mscorlib]System.MulticastDelegate
+{
+    .method public hidebysig specialname rtspecialname instance void .ctor (object 'object', native int 'method') runtime managed { }
+    .method public hidebysig newslot virtual instance int32 modreq([mscorlib]System.Int16) Invoke () runtime managed { }
+    .method public hidebysig newslot virtual instance class [mscorlib]System.IAsyncResult BeginInvoke (class [mscorlib]System.AsyncCallback callback, object 'object') runtime managed { }
+    .method public hidebysig newslot virtual instance int32 modreq([mscorlib]System.Int16) EndInvoke (class [mscorlib]System.IAsyncResult result) runtime managed { }
+}";
+            var refA = CompileIL(sourceA);
+
+            var sourceB =
+@"class Program
+{
+    static void F(D d)
+    {
+        System.Console.WriteLine(d());
+    }
+    static void Main()
+    {
+        F(() => 1);
+        F(int () => 2);
+    }
+}";
+            var comp = CreateCompilation(sourceB, references: new[] { refA }, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (5,34): error CS0570: 'D.Invoke()' is not supported by the language
+                //         System.Console.WriteLine(d());
+                Diagnostic(ErrorCode.ERR_BindToBogus, "d()").WithArguments("D.Invoke()").WithLocation(5, 34),
+                // (9,11): error CS0570: 'D.Invoke()' is not supported by the language
+                //         F(() => 1);
+                Diagnostic(ErrorCode.ERR_BindToBogus, "() => 1").WithArguments("D.Invoke()").WithLocation(9, 11),
+                // (10,11): error CS0570: 'D.Invoke()' is not supported by the language
+                //         F(int () => 2);
+                Diagnostic(ErrorCode.ERR_BindToBogus, "int () => 2").WithArguments("D.Invoke()").WithLocation(10, 11));
+        }
+
+        [Fact]
+        public void LambdaReturnType_UseSiteErrors()
+        {
+            var sourceA =
+@".class public sealed A extends [mscorlib]System.Object
+{
+  .custom instance void [mscorlib]System.Runtime.CompilerServices.RequiredAttributeAttribute::.ctor(class [mscorlib]System.Type) = ( 01 00 FF 00 00 ) 
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}";
+            var refA = CompileIL(sourceA);
+
+            var sourceB =
+@"using System;
+class B
+{
+    static void F<T>(Func<T> f) { }
+    static void Main()
+    {
+        F(A () => default);
+    }
+}";
+            var comp = CreateCompilation(sourceB, references: new[] { refA }, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (7,11): error CS0648: 'A' is a type not supported by the language
+                //         F(A () => default);
+                Diagnostic(ErrorCode.ERR_BogusType, "A").WithArguments("A").WithLocation(7, 11));
+        }
+
+        [Fact]
+        public void AsyncLambdaParameters_01()
+        {
+            var source =
+@"using System;
+using System.Threading.Tasks;
+delegate Task D(ref string s);
+class Program
+{
+    static void Main()
+    {
+        Delegate d1 = async (ref string s) => { _ = s.Length; await Task.Yield(); };
+        D d2 = async (ref string s) => { _ = s.Length; await Task.Yield(); };
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (8,23): error CS8917: The delegate type could not be inferred.
+                //         Delegate d1 = async (ref string s) => { _ = s.Length; await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "async (ref string s) => { _ = s.Length; await Task.Yield(); }").WithLocation(8, 23),
+                // (8,41): error CS1988: Async methods cannot have ref, in or out parameters
+                //         Delegate d1 = async (ref string s) => { _ = s.Length; await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_BadAsyncArgType, "s").WithLocation(8, 41),
+                // (9,34): error CS1988: Async methods cannot have ref, in or out parameters
+                //         D d2 = async (ref string s) => { _ = s.Length; await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_BadAsyncArgType, "s").WithLocation(9, 34));
+        }
+
+        [ConditionalFact(typeof(DesktopOnly))]
+        public void AsyncLambdaParameters_02()
+        {
+            var source =
+@"using System;
+using System.Threading.Tasks;
+delegate void D1(TypedReference r);
+delegate void D2(RuntimeArgumentHandle h);
+delegate void D3(ArgIterator i);
+class Program
+{
+    static void Main()
+    {
+        D1 d1 = async (TypedReference r) => { await Task.Yield(); };
+        D2 d2 = async (RuntimeArgumentHandle h) => { await Task.Yield(); };
+        D3 d3 = async (ArgIterator i) => { await Task.Yield(); };
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (10,39): error CS4012: Parameters or locals of type 'TypedReference' cannot be declared in async methods or async lambda expressions.
+                //         D1 d1 = async (TypedReference r) => { await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_BadSpecialByRefLocal, "r").WithArguments("System.TypedReference").WithLocation(10, 39),
+                // (11,46): error CS4012: Parameters or locals of type 'RuntimeArgumentHandle' cannot be declared in async methods or async lambda expressions.
+                //         D2 d2 = async (RuntimeArgumentHandle h) => { await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_BadSpecialByRefLocal, "h").WithArguments("System.RuntimeArgumentHandle").WithLocation(11, 46),
+                // (12,36): error CS4012: Parameters or locals of type 'ArgIterator' cannot be declared in async methods or async lambda expressions.
+                //         D3 d3 = async (ArgIterator i) => { await Task.Yield(); };
+                Diagnostic(ErrorCode.ERR_BadSpecialByRefLocal, "i").WithArguments("System.ArgIterator").WithLocation(12, 36));
+        }
+
+        [Fact]
+        public void BestType_01()
+        {
+            var source =
+@"using System;
+class A { }
+class B1 : A { }
+class B2 : A { }
+interface I { }
+class C1 : I { }
+class C2 : I { }
+class Program
+{
+    static void F<T>(Func<bool, T> f) { }
+    static void Main()
+    {
+        F((bool b) => { if (b) return new B1(); return new B2(); });
+        F((bool b) => { if (b) return new C1(); return new C2(); });
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (13,9): error CS0411: The type arguments for method 'Program.F<T>(Func<bool, T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F((bool b) => { if (b) return new B1(); return new B2(); });
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(System.Func<bool, T>)").WithLocation(13, 9),
+                // (14,9): error CS0411: The type arguments for method 'Program.F<T>(Func<bool, T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F((bool b) => { if (b) return new C1(); return new C2(); });
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(System.Func<bool, T>)").WithLocation(14, 9));
+        }
+
+        // As above but with explicit return type.
+        [Fact]
+        public void BestType_02()
+        {
+            var source =
+@"using System;
+class A { }
+class B1 : A { }
+class B2 : A { }
+interface I { }
+class C1 : I { }
+class C2 : I { }
+class Program
+{
+    static void F<T>(Func<bool, T> f) { Console.WriteLine(typeof(T)); }
+    static void Main()
+    {
+        F(A (bool b) => { if (b) return new B1(); return new B2(); });
+        F(I (bool b) => { if (b) return new C1(); return new C2(); });
+    }
+}";
+            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput:
+@"A
+I");
+        }
+
+        [Fact]
+        public void BestType_03()
+        {
+            var source =
+@"using System;
+class A { }
+class B1 : A { }
+class B2 : A { }
+class Program
+{
+    static void F<T>(Func<T> x, Func<T> y) { }
+    static void Main()
+    {
+        F(B2 () => null, B2 () => null);
+        F(A () => null, B2 () => null);
+        F(B1 () => null, B2 () => null);
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (11,25): error CS8934: Cannot convert lambda expression to type 'Func<A>' because the return type does not match the delegate return type
+                //         F(A () => null, B2 () => null);
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturnType, "B2 () => null").WithArguments("lambda expression", "System.Func<A>").WithLocation(11, 25),
+                // (12,9): error CS0411: The type arguments for method 'Program.F<T>(Func<T>, Func<T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F(B1 () => null, B2 () => null);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(System.Func<T>, System.Func<T>)").WithLocation(12, 9));
+        }
+
+        [Fact]
+        public void TypeInference_01()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F<T>(Func<object, T> f)
+    {
+        Console.WriteLine(typeof(T));
+    }
+    static void Main()
+    {
+        F(long (o) => 1);
+    }
+}";
+            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput: @"System.Int64");
+        }
+
+        // Should method type inference make an explicit type inference
+        // from the lambda expression return type?
+        [Fact]
+        public void TypeInference_02()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F<T>(Func<T, T> f)
+    {
+        Console.WriteLine(typeof(T));
+    }
+    static void Main()
+    {
+        F(int (i) => i);
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (10,9): error CS0411: The type arguments for method 'Program.F<T>(Func<T, T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F(int (i) => i);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(System.Func<T, T>)").WithLocation(10, 9));
+        }
+
+        // CS4031 is not reported for async lambda in [SecurityCritical] type.
+        [Fact]
+        [WorkItem(54074, "https://github.com/dotnet/roslyn/issues/54074")]
+        public void SecurityCritical_AsyncLambda()
+        {
+            var source =
+@"using System;
+using System.Security;
+using System.Threading.Tasks;
+[SecurityCritical]
+class Program
+{
+    static void Main()
+    {
+        Func<Task> f = async () => await Task.Yield();
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics();
+        }
+
+        // CS4031 is not reported for async lambda in [SecurityCritical] type.
+        [Fact]
+        [WorkItem(54074, "https://github.com/dotnet/roslyn/issues/54074")]
+        public void SecurityCritical_AsyncLambda_AttributeArgument()
+        {
+            var source =
+@"using System;
+using System.Security;
+using System.Threading.Tasks;
+class A : Attribute
+{
+    internal A(int i) { }
+}
+[SecurityCritical]
+[A(F(async () => await Task.Yield()))]
+class Program
+{
+    internal static int F(Func<Task> f) => 0;
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (9,4): error CS0182: An attribute argument must be a constant expression, typeof expression or array creation expression of an attribute parameter type
+                // [A(F(async () => await Task.Yield()))]
+                Diagnostic(ErrorCode.ERR_BadAttributeArgument, "F(async () => await Task.Yield())").WithLocation(9, 4));
+        }
+
         private static LambdaSymbol GetLambdaSymbol(SemanticModel model, LambdaExpressionSyntax syntax)
         {
             return model.GetSymbolInfo(syntax).Symbol.GetSymbol<LambdaSymbol>();
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs
index 9daf64427a68e..135624fcdfa2d 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs
@@ -1674,7 +1674,7 @@ void M()
             comp.DeclarationDiagnostics.Verify();
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/16652")]
+        [Fact]
         public void FetchLocalFunctionSymbolThroughLocal()
         {
             var tree = SyntaxFactory.ParseSyntaxTree(@"
@@ -1692,30 +1692,28 @@ void Local<[A, B, CLSCompliant, D]T>()
 }");
             var comp = CreateCompilation(tree);
             comp.DeclarationDiagnostics.Verify();
+
             comp.VerifyDiagnostics(
-                // (7,20): error CS8204: Attributes are not allowed on local function parameters or type parameters
-                //         void Local<[A, B, CLSCompliant, D]T>() { }
-                Diagnostic(ErrorCode.ERR_AttributesInLocalFuncDecl, "[A, B, CLSCompliant, D]").WithLocation(7, 20),
                 // (7,21): error CS0246: The type or namespace name 'AAttribute' could not be found (are you missing a using directive or an assembly reference?)
-                //         void Local<[A, B, CLSCompliant, D]T>() { }
+                //         void Local<[A, B, CLSCompliant, D]T>() 
                 Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "A").WithArguments("AAttribute").WithLocation(7, 21),
                 // (7,21): error CS0246: The type or namespace name 'A' could not be found (are you missing a using directive or an assembly reference?)
-                //         void Local<[A, B, CLSCompliant, D]T>() { }
+                //         void Local<[A, B, CLSCompliant, D]T>() 
                 Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "A").WithArguments("A").WithLocation(7, 21),
                 // (7,24): error CS0246: The type or namespace name 'BAttribute' could not be found (are you missing a using directive or an assembly reference?)
-                //         void Local<[A, B, CLSCompliant, D]T>() { }
+                //         void Local<[A, B, CLSCompliant, D]T>() 
                 Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "B").WithArguments("BAttribute").WithLocation(7, 24),
                 // (7,24): error CS0246: The type or namespace name 'B' could not be found (are you missing a using directive or an assembly reference?)
-                //         void Local<[A, B, CLSCompliant, D]T>() { }
+                //         void Local<[A, B, CLSCompliant, D]T>() 
                 Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "B").WithArguments("B").WithLocation(7, 24),
                 // (7,41): error CS0246: The type or namespace name 'DAttribute' could not be found (are you missing a using directive or an assembly reference?)
-                //         void Local<[A, B, CLSCompliant, D]T>() { }
+                //         void Local<[A, B, CLSCompliant, D]T>() 
                 Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "D").WithArguments("DAttribute").WithLocation(7, 41),
                 // (7,41): error CS0246: The type or namespace name 'D' could not be found (are you missing a using directive or an assembly reference?)
-                //         void Local<[A, B, CLSCompliant, D]T>() { }
+                //         void Local<[A, B, CLSCompliant, D]T>() 
                 Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "D").WithArguments("D").WithLocation(7, 41),
                 // (7,27): error CS7036: There is no argument given that corresponds to the required formal parameter 'isCompliant' of 'CLSCompliantAttribute.CLSCompliantAttribute(bool)'
-                //         void Local<[A, B, CLSCompliant, D]T>() { }
+                //         void Local<[A, B, CLSCompliant, D]T>() 
                 Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "CLSCompliant").WithArguments("isCompliant", "System.CLSCompliantAttribute.CLSCompliantAttribute(bool)").WithLocation(7, 27));
 
             var model = comp.GetSemanticModel(tree);
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NameOfTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NameOfTests.cs
index 0a0dc8c945aac..de720a32d6e23 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NameOfTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NameOfTests.cs
@@ -5,10 +5,8 @@
 #nullable disable
 
 using System;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
-using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
 using System.Threading;
@@ -243,33 +241,15 @@ class Test<T>
                 // (12,20): error CS1525: Invalid expression term 'int'
                 //         s = nameof(int);
                 Diagnostic(ErrorCode.ERR_InvalidExprTerm, "int").WithArguments("int").WithLocation(12, 20),
-                // (13,20): error CS1026: ) expected
+                // (13,20): error CS1525: Invalid expression term 'void'
                 //         s = nameof(void);
-                Diagnostic(ErrorCode.ERR_CloseParenExpected, "void").WithLocation(13, 20),
-                // (13,20): error CS1002: ; expected
-                //         s = nameof(void);
-                Diagnostic(ErrorCode.ERR_SemicolonExpected, "void").WithLocation(13, 20),
-                // (13,20): error CS1547: Keyword 'void' cannot be used in this context
-                //         s = nameof(void);
-                Diagnostic(ErrorCode.ERR_NoVoidHere, "void").WithLocation(13, 20),
-                // (13,24): error CS1001: Identifier expected
-                //         s = nameof(void);
-                Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(13, 24),
-                // (13,24): error CS1002: ; expected
-                //         s = nameof(void);
-                Diagnostic(ErrorCode.ERR_SemicolonExpected, ")").WithLocation(13, 24),
-                // (13,24): error CS1513: } expected
-                //         s = nameof(void);
-                Diagnostic(ErrorCode.ERR_RbraceExpected, ")").WithLocation(13, 24),
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "void").WithArguments("void").WithLocation(13, 20),
                 // (17,66): error CS1031: Type expected
                 //         s = nameof(System.Collections.Generic.Dictionary<Program,>.KeyCollection);
                 Diagnostic(ErrorCode.ERR_TypeExpected, ">").WithLocation(17, 66),
                 // (11,27): error CS0305: Using the generic type 'Action<T>' requires 1 type arguments
                 //         s = nameof(System.Action<>);
                 Diagnostic(ErrorCode.ERR_BadArity, "Action<>").WithArguments("System.Action<T>", "type", "1").WithLocation(11, 27),
-                // (13,13): error CS0103: The name 'nameof' does not exist in the current context
-                //         s = nameof(void);
-                Diagnostic(ErrorCode.ERR_NameNotInContext, "nameof").WithArguments("nameof").WithLocation(13, 13),
                 // (16,20): error CS0103: The name 'List' does not exist in the current context
                 //         s = nameof(List<int>.Enumerator);
                 Diagnostic(ErrorCode.ERR_NameNotInContext, "List<int>").WithArguments("List").WithLocation(16, 20),
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index 86e8df3ecea6d..d083ea601f15a 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -1945,13 +1945,13 @@ static void M(A a)
         }
     }
 }";
-            CreateCompilation(source).VerifyDiagnostics(
+            CreateCompilation(source, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
                 // (8,9): error CS1656: Cannot assign to 'E' because it is a 'method group'
                 //         a.E! += a.E!; // 1
                 Diagnostic(ErrorCode.ERR_AssgReadonlyLocalCause, "a.E").WithArguments("E", "method group").WithLocation(8, 9),
-                // (9,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (9,13): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         if (a.E! != null) // 2
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "a.E").WithArguments("inferred delegate type").WithLocation(9, 13),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "a.E").WithArguments("inferred delegate type", "10.0").WithLocation(9, 13),
                 // (11,15): error CS1503: Argument 1: cannot convert from 'method group' to 'A'
                 //             M(a.E!); // 3
                 Diagnostic(ErrorCode.ERR_BadArgType, "a.E").WithArguments("1", "method group", "A").WithLocation(11, 15),
@@ -1970,9 +1970,9 @@ static void M(A a)
                 // (17,9): error CS1656: Cannot assign to 'F' because it is a 'method group'
                 //         a.F! += a.F!; // 8
                 Diagnostic(ErrorCode.ERR_AssgReadonlyLocalCause, "a.F").WithArguments("F", "method group").WithLocation(17, 9),
-                // (18,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (18,13): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         if (a.F! != null) // 9
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "a.F").WithArguments("inferred delegate type").WithLocation(18, 13),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "a.F").WithArguments("inferred delegate type", "10.0").WithLocation(18, 13),
                 // (20,15): error CS1503: Argument 1: cannot convert from 'method group' to 'A'
                 //             M(a.F!); // 10
                 Diagnostic(ErrorCode.ERR_BadArgType, "a.F").WithArguments("1", "method group", "A").WithLocation(20, 15),
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs
index 3e106a36789ee..44d5fc2dd4851 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs
@@ -6051,7 +6051,7 @@ public static explicit operator (T1 fst, T2 snd)((T1 one, T2 two) s)
 }
 ";
             CreateCompilation(text).VerifyDiagnostics(
-                // (6,41): error CS0555: User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type
+                // (6,41): error CS0555: User-defined operator cannot convert a type to itself
                 //         public static explicit operator (T1 fst, T2 snd)((T1 one, T2 two) s)
                 Diagnostic(ErrorCode.ERR_IdentityConversion, "(T1 fst, T2 snd)").WithLocation(6, 41));
         }
@@ -8569,7 +8569,7 @@ static object F(int i)
             var op = visitor.FirstNode.Operator;
             Assert.Null(op.Method);
             // Equals and GetHashCode should support null Method.
-            Assert.Equal(op, new BinaryOperatorSignature(op.Kind, op.LeftType, op.RightType, op.ReturnType, op.Method));
+            Assert.Equal(op, new BinaryOperatorSignature(op.Kind, op.LeftType, op.RightType, op.ReturnType, op.Method, constrainedToTypeOpt: null));
             op.GetHashCode();
         }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests5.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests5.cs
index f336211da27bb..2fb1dd4436933 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests5.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests5.cs
@@ -522,7 +522,7 @@ class C { public object Prop3 => null; }
     Statements (0)
 ";
 
-            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(src, expectedFlowGraph, DiagnosticDescription.None, parseOptions: TestOptions.RegularPreview);
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(src, expectedFlowGraph, DiagnosticDescription.None, parseOptions: TestOptions.Regular10);
         }
 
         [Fact]
@@ -684,7 +684,7 @@ struct C { public object Field3; }
     Statements (0)
 ";
 
-            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(src, expectedFlowGraph, expectedDiagnostics, parseOptions: TestOptions.RegularPreview);
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(src, expectedFlowGraph, expectedDiagnostics, parseOptions: TestOptions.Regular10);
         }
 
         [Fact]
@@ -1503,9 +1503,9 @@ public void Deconstruct(out C c1, out C c2)
 ";
             var compilation = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             compilation.VerifyEmitDiagnostics(
-                // (8,22): error CS8652: The feature 'extended property patterns' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (8,22): error CS8773: Feature 'extended property patterns' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         _ = this is (Property.Property: null, Property: null);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "Property.Property").WithArguments("extended property patterns").WithLocation(8, 22),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "Property.Property").WithArguments("extended property patterns", "10.0").WithLocation(8, 22),
                 // (8,22): error CS1001: Identifier expected
                 //         _ = this is (Property.Property: null, Property: null);
                 Diagnostic(ErrorCode.ERR_IdentifierExpected, "Property.Property").WithLocation(8, 22),
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
index 4fe37305c5c55..75948efc9befc 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
@@ -281,19 +281,19 @@ record struct Point(int x, int y);
 
             comp = CreateCompilation(new[] { src2, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseDll);
             comp.VerifyDiagnostics(
-                // (2,8): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (2,8): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record struct Point { }
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "struct").WithArguments("record structs").WithLocation(2, 8)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(2, 8)
                 );
 
             comp = CreateCompilation(new[] { src3, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseDll);
             comp.VerifyDiagnostics(
-                // (2,8): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                // record struct Point(int x, int y);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "struct").WithArguments("record structs").WithLocation(2, 8)
+                // (2,8): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // record struct Point { }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(2, 8)
                 );
 
-            comp = CreateCompilation(new[] { src1, IsExternalInitTypeDefinition }, parseOptions: TestOptions.RegularPreview, options: TestOptions.ReleaseDll);
+            comp = CreateCompilation(new[] { src1, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseDll);
             comp.VerifyDiagnostics(
                 // (2,13): error CS1514: { expected
                 // struct Point(int x, int y);
@@ -324,10 +324,10 @@ record struct Point(int x, int y);
                 Diagnostic(ErrorCode.ERR_UseDefViolation, "int y").WithArguments("y").WithLocation(2, 21)
                 );
 
-            comp = CreateCompilation(new[] { src2, IsExternalInitTypeDefinition }, parseOptions: TestOptions.RegularPreview, options: TestOptions.ReleaseDll);
+            comp = CreateCompilation(new[] { src2, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseDll);
             comp.VerifyDiagnostics();
 
-            comp = CreateCompilation(new[] { src3, IsExternalInitTypeDefinition }, parseOptions: TestOptions.RegularPreview, options: TestOptions.ReleaseDll);
+            comp = CreateCompilation(new[] { src3, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseDll);
             comp.VerifyDiagnostics();
         }
 
@@ -376,23 +376,23 @@ record struct Point { }
 
             comp = CreateCompilation(new[] { src2, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (4,12): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (4,12): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     record struct Point { }
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "struct").WithArguments("record structs").WithLocation(4, 12)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(4, 12)
                 );
 
             comp = CreateCompilation(new[] { src3, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (4,12): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (4,12): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     record struct Point(int x, int y);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "struct").WithArguments("record structs").WithLocation(4, 12)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(4, 12)
                 );
 
             comp = CreateCompilation(src4, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (4,12): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (4,12): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     record struct Point { }
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "struct").WithArguments("record structs").WithLocation(4, 12)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(4, 12)
                 );
 
             comp = CreateCompilation(src1);
@@ -2959,7 +2959,7 @@ public static class IsExternalInit
 }
 ";
 
-            var comp = CreateCompilation(src, parseOptions: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.Preview));
+            var comp = CreateCompilation(src, parseOptions: TestOptions.RegularWithDocumentationComments);
             comp.VerifyDiagnostics();
 
             var cMember = comp.GetMember<NamedTypeSymbol>("C");
@@ -3005,7 +3005,7 @@ public static class IsExternalInit
 }
 ";
 
-            var comp = CreateCompilation(src, parseOptions: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.Preview));
+            var comp = CreateCompilation(src, parseOptions: TestOptions.RegularWithDocumentationComments);
             comp.VerifyDiagnostics(
                 // (7,52): warning CS1574: XML comment has cref attribute 'x' that could not be resolved
                 //     /// <param name="x">Description for <see cref="x"/></param>
@@ -6449,9 +6449,9 @@ public B M()
 }";
             var comp = CreateCompilation(src, parseOptions: TestOptions.Regular9);
             comp.VerifyEmitDiagnostics(
-                // (13,16): error CS8652: The feature 'with on structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (13,16): error CS8773: Feature 'with on structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         return this with { X = 42 };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "this with { X = 42 }").WithArguments("with on structs").WithLocation(13, 16)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "this with { X = 42 }").WithArguments("with on structs", "10.0").WithLocation(13, 16)
                 );
 
             comp = CreateCompilation(src);
@@ -7775,12 +7775,12 @@ static T Identity<T>(T t)
 }";
             var comp = CreateCompilation(src, parseOptions: TestOptions.Regular9);
             comp.VerifyEmitDiagnostics(
-                // (9,17): error CS8652: The feature 'with on anonymous types' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (9,17): error CS8773: Feature 'with on anonymous types' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         var b = Identity(a) with { A = Identity(30), B = Identity(40) };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "Identity(a) with { A = Identity(30), B = Identity(40) }").WithArguments("with on anonymous types").WithLocation(9, 17)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "Identity(a) with { A = Identity(30), B = Identity(40) }").WithArguments("with on anonymous types", "10.0").WithLocation(9, 17)
                 );
 
-            comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilation(src, parseOptions: TestOptions.Regular10);
             comp.VerifyEmitDiagnostics();
             var verifier = CompileAndVerify(comp, expectedOutput: "Identity({ A = 10, B = 20 }) Identity(30) Identity(40) { A = 30, B = 40 }");
             verifier.VerifyIL("C.M", @"
@@ -9742,7 +9742,6 @@ public static void M()
             var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreview);
             comp.VerifyEmitDiagnostics(expectedDiagnostics);
 
-            // TODO2
             var expectedFlowGraph = @"
 Block[B0] - Entry
     Statements (0)
@@ -9993,6 +9992,35 @@ public static void M()
             VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(src, expectedFlowGraph, expectedDiagnostics, parseOptions: TestOptions.RegularPreview);
         }
 
+        [Fact, WorkItem(53849, "https://github.com/dotnet/roslyn/issues/53849")]
+        public void WithExpr_AnonymousType_ValueIsLoweredToo()
+        {
+            var src = @"
+var x = new { Property = 42 };
+var adjusted = x with { Property = x.Property + 2 };
+
+System.Console.WriteLine(adjusted);
+";
+            var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreview);
+            var verifier = CompileAndVerify(comp, expectedOutput: "{ Property = 44 }");
+            verifier.VerifyDiagnostics();
+        }
+
+        [Fact, WorkItem(53849, "https://github.com/dotnet/roslyn/issues/53849")]
+        public void WithExpr_AnonymousType_ValueIsLoweredToo_NestedWith()
+        {
+            var src = @"
+var x = new { Property = 42 };
+var container = new { Item = x };
+var adjusted = container with { Item = x with { Property = x.Property + 2 } };
+
+System.Console.WriteLine(adjusted);
+";
+            var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreview);
+            var verifier = CompileAndVerify(comp, expectedOutput: "{ Item = { Property = 44 } }");
+            verifier.VerifyDiagnostics();
+        }
+
         [Fact]
         public void AttributesOnPrimaryConstructorParameters_01()
         {
@@ -10070,15 +10098,15 @@ record struct A(int X)
 ";
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyEmitDiagnostics(
-                // (8,8): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (8,8): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record struct A(int X)
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "struct").WithArguments("record structs").WithLocation(8, 8),
-                // (8,17): error CS8652: The feature 'positional fields in records' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(8, 8),
+                // (8,17): error CS8773: Feature 'positional fields in records' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record struct A(int X)
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "int X").WithArguments("positional fields in records").WithLocation(8, 17)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "int X").WithArguments("positional fields in records", "10.0").WithLocation(8, 17)
                 );
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics();
             var verifier = CompileAndVerify(comp, expectedOutput: "42 - 42");
             verifier.VerifyIL("A.Deconstruct", @"
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
index 9d48894caf363..b8cb91b2b0b9a 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
@@ -282,12 +282,12 @@ record class Point(int x, int y);
 
             comp = CreateCompilation(new[] { src, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseDll);
             comp.VerifyDiagnostics(
-                // (2,8): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (2,8): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record class Point(int x, int y);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "class").WithArguments("record structs").WithLocation(2, 8)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "class").WithArguments("record structs", "10.0").WithLocation(2, 8)
                 );
 
-            comp = CreateCompilation(new[] { src, IsExternalInitTypeDefinition }, parseOptions: TestOptions.RegularPreview, options: TestOptions.ReleaseDll);
+            comp = CreateCompilation(new[] { src, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseDll);
             comp.VerifyDiagnostics();
         }
 
@@ -852,7 +852,7 @@ public partial record class C
     public int P2 { get; set; } = X;
 }
 ";
-            var comp = CreateCompilation(new[] { src, IsExternalInitTypeDefinition }, options: TestOptions.DebugExe, parseOptions: TestOptions.RegularPreview);
+            var comp = CreateCompilation(new[] { src, IsExternalInitTypeDefinition }, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular10);
             CompileAndVerify(comp, expectedOutput: "(2, 2)", verify: Verification.Skipped /* init-only */).VerifyDiagnostics();
         }
 
@@ -1106,7 +1106,7 @@ public void RecordProperties_05_RecordClass()
 record class C(int X, int X)
 {
 }";
-            var comp = CreateCompilation(new[] { src, IsExternalInitTypeDefinition }, parseOptions: TestOptions.RegularPreview);
+            var comp = CreateCompilation(new[] { src, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics(
                 // (2,27): error CS0100: The parameter name 'X' is a duplicate
                 // record class C(int X, int X)
@@ -1247,9 +1247,9 @@ class P1 { }
                 // (1,17): error CS0102: The type 'C' already contains a definition for 'P1'
                 // record C(object P1, object P2, object P3, object P4)
                 Diagnostic(ErrorCode.ERR_DuplicateNameInClass, "P1").WithArguments("C", "P1").WithLocation(1, 17),
-                // (1,21): error CS8652: The feature 'positional fields in records' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,21): error CS8773: Feature 'positional fields in records' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record C(object P1, object P2, object P3, object P4)
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "object P2").WithArguments("positional fields in records").WithLocation(1, 21),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "object P2").WithArguments("positional fields in records", "10.0").WithLocation(1, 21),
                 // (1,28): warning CS8907: Parameter 'P2' is unread. Did you forget to use it to initialize the property with that name?
                 // record C(object P1, object P2, object P3, object P4)
                 Diagnostic(ErrorCode.WRN_UnreadRecordParameter, "P2").WithArguments("P2").WithLocation(1, 28),
@@ -1261,7 +1261,7 @@ class P1 { }
                 Diagnostic(ErrorCode.ERR_DuplicateNameInClass, "P4").WithArguments("C", "P4").WithLocation(6, 9)
                 );
 
-            comp = CreateCompilation(new[] { src, IsExternalInitTypeDefinition }, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilation(new[] { src, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics(
                 // (1,17): error CS0102: The type 'C' already contains a definition for 'P1'
                 // record C(object P1, object P2, object P3, object P4)
@@ -1667,7 +1667,7 @@ static void Main()
 }
 ";
 
-            var verifier = CompileAndVerify(src, expectedOutput: "True", parseOptions: TestOptions.RegularPreview);
+            var verifier = CompileAndVerify(src, expectedOutput: "True", parseOptions: TestOptions.Regular10);
             verifier.VerifyDiagnostics();
 
             verifier.VerifyIL("C..ctor()", @"
@@ -2765,9 +2765,9 @@ public override void M<U>(U t)
 }";
             var comp = CreateCompilationWithIL(new[] { src, IsExternalInitTypeDefinition }, ilSource: ilSource, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (11,13): error CS8652: The feature 'with on structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (11,13): error CS8773: Feature 'with on structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         _ = t with { X = 2, Property = 3 };
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "t with { X = 2, Property = 3 }").WithArguments("with on structs").WithLocation(11, 13),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "t with { X = 2, Property = 3 }").WithArguments("with on structs", "10.0").WithLocation(11, 13),
                 // (11,22): error CS0117: 'U' does not contain a definition for 'X'
                 //         _ = t with { X = 2, Property = 3 };
                 Diagnostic(ErrorCode.ERR_NoSuchMember, "X").WithArguments("U", "X").WithLocation(11, 22),
@@ -2776,7 +2776,7 @@ public override void M<U>(U t)
                 Diagnostic(ErrorCode.ERR_NoSuchMember, "Property").WithArguments("U", "Property").WithLocation(11, 29)
                 );
 
-            comp = CreateCompilationWithIL(new[] { src, IsExternalInitTypeDefinition }, ilSource: ilSource, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilationWithIL(new[] { src, IsExternalInitTypeDefinition }, ilSource: ilSource, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics(
                 // (11,22): error CS0117: 'U' does not contain a definition for 'X'
                 //         _ = t with { X = 2, Property = 3 };
@@ -5988,7 +5988,7 @@ record C1
 record C2 : C1;
 ";
 
-            var comp = CreateCompilation(src, parseOptions: usePreview ? TestOptions.RegularPreview : TestOptions.Regular9, options: TestOptions.DebugExe);
+            var comp = CreateCompilation(src, parseOptions: usePreview ? TestOptions.Regular10 : TestOptions.Regular9, options: TestOptions.DebugExe);
             if (usePreview)
             {
                 comp.VerifyEmitDiagnostics();
@@ -5997,9 +5997,9 @@ record C2 : C1;
             else
             {
                 comp.VerifyEmitDiagnostics(
-                    // (4,35): error CS8652: The feature 'sealed ToString in record' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                    //     public sealed override string ToString() => throw null;
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "ToString").WithArguments("sealed ToString in record").WithLocation(7, 35)
+                    // (7,35): error CS8773: Feature 'sealed ToString in record' is not available in C# 9.0. Please use language version 10.0 or greater.
+                    //     public sealed override string ToString() => "C1";
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "ToString").WithArguments("sealed ToString in record", "10.0").WithLocation(7, 35)
                     );
             }
         }
@@ -7376,7 +7376,7 @@ public record B : A {
             var comp = CreateCompilationWithIL(
                 new[] { source, IsExternalInitTypeDefinition },
                 ilSource: ilSource,
-                parseOptions: usePreview ? TestOptions.RegularPreview : TestOptions.Regular9);
+                parseOptions: usePreview ? TestOptions.Regular10 : TestOptions.Regular9);
             if (usePreview)
             {
                 comp.VerifyEmitDiagnostics();
@@ -7385,9 +7385,9 @@ public record B : A {
             else
             {
                 comp.VerifyEmitDiagnostics(
-                    // (2,1): error CS8912: Inheriting from a record with a sealed 'Object.ToString' is not supported in C# 9.0. Please use language version 'preview' or greater.
-                    // record B : A
-                    Diagnostic(ErrorCode.ERR_InheritingFromRecordWithSealedToString, "B").WithArguments("9.0", "preview").WithLocation(5, 15)
+                    // (5,15): error CS8912: Inheriting from a record with a sealed 'Object.ToString' is not supported in C# 9.0. Please use language version '10.0' or greater.
+                    // public record B : A {
+                    Diagnostic(ErrorCode.ERR_InheritingFromRecordWithSealedToString, "B").WithArguments("9.0", "10.0").WithLocation(5, 15)
                     );
             }
         }
@@ -7425,7 +7425,7 @@ record C1
 }
 ";
 
-            var comp = CreateCompilation(src, parseOptions: usePreview ? TestOptions.RegularPreview : TestOptions.Regular9);
+            var comp = CreateCompilation(src, parseOptions: usePreview ? TestOptions.Regular10 : TestOptions.Regular9);
             if (usePreview)
             {
                 comp.VerifyEmitDiagnostics();
@@ -7433,9 +7433,9 @@ record C1
             else
             {
                 comp.VerifyEmitDiagnostics(
-                    // (4,35): error CS8652: The feature 'sealed ToString in record' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    // (4,35): error CS8773: Feature 'sealed ToString in record' is not available in C# 9.0. Please use language version 10.0 or greater.
                     //     public sealed override string ToString() => throw null;
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "ToString").WithArguments("sealed ToString in record").WithLocation(4, 35)
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "ToString").WithArguments("sealed ToString in record", "10.0").WithLocation(4, 35)
                     );
             }
         }
@@ -10044,9 +10044,9 @@ static void Main()
                 // (7,21): warning CS8907: Parameter 'Y' is unread. Did you forget to use it to initialize the property with that name?
                 // record B(int X, int Y, int Z) : A
                 Diagnostic(ErrorCode.WRN_UnreadRecordParameter, "Y").WithArguments("Y").WithLocation(7, 21),
-                // (7,24): error CS8652: The feature 'positional fields in records' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (7,24): error CS8773: Feature 'positional fields in records' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record B(int X, int Y, int Z) : A
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "int Z").WithArguments("positional fields in records").WithLocation(7, 24),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "int Z").WithArguments("positional fields in records", "10.0").WithLocation(7, 24),
                 // (7,28): warning CS8907: Parameter 'Z' is unread. Did you forget to use it to initialize the property with that name?
                 // record B(int X, int Y, int Z) : A
                 Diagnostic(ErrorCode.WRN_UnreadRecordParameter, "Z").WithArguments("Z").WithLocation(7, 28));
@@ -10905,9 +10905,9 @@ public class P1 { }
                 // (1,17): warning CS8907: Parameter 'P1' is unread. Did you forget to use it to initialize the property with that name?
                 // record B(object P1, object P2, object P3, object P4) : A
                 Diagnostic(ErrorCode.WRN_UnreadRecordParameter, "P1").WithArguments("P1").WithLocation(1, 17),
-                // (1,21): error CS8652: The feature 'positional fields in records' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,21): error CS8773: Feature 'positional fields in records' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record B(object P1, object P2, object P3, object P4) : A
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "object P2").WithArguments("positional fields in records").WithLocation(1, 21),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "object P2").WithArguments("positional fields in records", "10.0").WithLocation(1, 21),
                 // (1,28): warning CS8907: Parameter 'P2' is unread. Did you forget to use it to initialize the property with that name?
                 // record B(object P1, object P2, object P3, object P4) : A
                 Diagnostic(ErrorCode.WRN_UnreadRecordParameter, "P2").WithArguments("P2").WithLocation(1, 28),
@@ -14556,9 +14556,9 @@ static void Main()
 ";
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyEmitDiagnostics(
-                // (4,10): error CS8652: The feature 'positional fields in records' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (4,10): error CS8773: Feature 'positional fields in records' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record C(int X)
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "int X").WithArguments("positional fields in records").WithLocation(4, 10),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "int X").WithArguments("positional fields in records", "10.0").WithLocation(4, 10),
                 // (4,14): warning CS8907: Parameter 'X' is unread. Did you forget to use it to initialize the property with that name?
                 // record C(int X)
                 Diagnostic(ErrorCode.WRN_UnreadRecordParameter, "X").WithArguments("X").WithLocation(4, 14),
@@ -14567,7 +14567,7 @@ static void Main()
                 Diagnostic(ErrorCode.WRN_UnreferencedField, "X").WithArguments("C.X").WithLocation(6, 9)
                 );
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics(
                 // (4,14): warning CS8907: Parameter 'X' is unread. Did you forget to use it to initialize the property with that name?
                 // record C(int X)
@@ -15827,7 +15827,7 @@ public void Overrides_01(bool usePreview)
 record B(int X, int Y) : A
 {
 }";
-            var comp = CreateCompilation(new[] { source, IsExternalInitTypeDefinition }, parseOptions: usePreview ? TestOptions.RegularPreview : TestOptions.Regular9);
+            var comp = CreateCompilation(new[] { source, IsExternalInitTypeDefinition }, parseOptions: usePreview ? TestOptions.Regular10 : TestOptions.Regular9);
             if (usePreview)
             {
                 comp.VerifyDiagnostics(
@@ -15845,15 +15845,15 @@ record B(int X, int Y) : A
             else
             {
                 comp.VerifyDiagnostics(
-                    // (3,33): error CS0111: Type 'A' already defines a member called 'Equals' with the same parameter types
-                    //     public sealed override bool Equals(object other) => false;
-                    Diagnostic(ErrorCode.ERR_MemberAlreadyExists, "Equals").WithArguments("Equals", "A").WithLocation(3, 33),
-                    // (5,35): error CS8652: The feature 'sealed ToString in record' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                    //     public sealed override string ToString() => null;
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "ToString").WithArguments("sealed ToString in record").WithLocation(5, 35),
                     // (4,32): error CS8870: 'A.GetHashCode()' cannot be sealed because containing record is not sealed.
                     //     public sealed override int GetHashCode() => 0;
                     Diagnostic(ErrorCode.ERR_SealedAPIInRecord, "GetHashCode").WithArguments("A.GetHashCode()").WithLocation(4, 32),
+                    // (5,35): error CS8773: Feature 'sealed ToString in record' is not available in C# 9.0. Please use language version 10.0 or greater.
+                    //     public sealed override string ToString() => null;
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "ToString").WithArguments("sealed ToString in record", "10.0").WithLocation(5, 35),
+                    // (3,33): error CS0111: Type 'A' already defines a member called 'Equals' with the same parameter types
+                    //     public sealed override bool Equals(object other) => false;
+                    Diagnostic(ErrorCode.ERR_MemberAlreadyExists, "Equals").WithArguments("Equals", "A").WithLocation(3, 33),
                     // (7,8): error CS0239: 'B.GetHashCode()': cannot override inherited member 'A.GetHashCode()' because it is sealed
                     // record B(int X, int Y) : A
                     Diagnostic(ErrorCode.ERR_CantOverrideSealed, "B").WithArguments("B.GetHashCode()", "A.GetHashCode()").WithLocation(7, 8)
@@ -18809,7 +18809,7 @@ record B : A;
 ";
             var comp = CreateCompilation(source);
             comp.VerifyEmitDiagnostics(
-                // (2,8): error CS0736: 'A' does not implement interface member 'IEquatable<A>.Equals(A)'. 'A.Equals(A)' cannot implement an interface member because it is static.
+                // (2,8): error CS0736: 'A' does not implement instance interface member 'IEquatable<A>.Equals(A)'. 'A.Equals(A)' cannot implement the interface member because it is static.
                 // record A
                 Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "A").WithArguments("A", "System.IEquatable<A>.Equals(A)", "A.Equals(A)").WithLocation(2, 8),
                 // (4,24): error CS8872: 'A.Equals(A)' must allow overriding because the containing record is not sealed.
@@ -18836,7 +18836,7 @@ sealed record A
 ";
             var comp = CreateCompilation(source);
             comp.VerifyEmitDiagnostics(
-                // (2,15): error CS0736: 'A' does not implement interface member 'IEquatable<A>.Equals(A)'. 'A.Equals(A)' cannot implement an interface member because it is static.
+                // (2,15): error CS0736: 'A' does not implement instance interface member 'IEquatable<A>.Equals(A)'. 'A.Equals(A)' cannot implement the interface member because it is static.
                 // sealed record A
                 Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "A").WithArguments("A", "System.IEquatable<A>.Equals(A)", "A.Equals(A)").WithLocation(2, 15),
                 // (4,24): error CS8877: Record member 'A.Equals(A)' may not be static.
@@ -20706,7 +20706,7 @@ public static bool Equals(A other)
 ";
             var comp = CreateCompilation(source);
             comp.VerifyEmitDiagnostics(
-                // (2,8): error CS0736: 'A' does not implement interface member 'IEquatable<A>.Equals(A)'. 'A.Equals(A)' cannot implement an interface member because it is static.
+                // (2,8): error CS0736: 'A' does not implement instance interface member 'IEquatable<A>.Equals(A)'. 'A.Equals(A)' cannot implement the interface member because it is static.
                 // record A
                 Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "A").WithArguments("A", "System.IEquatable<A>.Equals(A)", "A.Equals(A)").WithLocation(2, 8),
                 // (4,24): error CS8872: 'A.Equals(A)' must allow overriding because the containing record is not sealed.
@@ -28054,7 +28054,7 @@ public static class IsExternalInit
 }
 ";
 
-            var comp = CreateCompilation(src, parseOptions: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.Preview));
+            var comp = CreateCompilation(src, parseOptions: TestOptions.RegularWithDocumentationComments);
             comp.VerifyDiagnostics();
 
             var cMember = comp.GetMember<NamedTypeSymbol>("C");
@@ -28972,12 +28972,12 @@ record A(int X)
 ";
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyEmitDiagnostics(
-                // (8,10): error CS8652: The feature 'positional fields in records' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                // record A(int X)
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "int X").WithArguments("positional fields in records").WithLocation(8, 10)
+                    // (8,10): error CS8773: Feature 'positional fields in records' is not available in C# 9.0. Please use language version 10.0 or greater.
+                    // record A(int X)
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "int X").WithArguments("positional fields in records", "10.0").WithLocation(8, 10)
                 );
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics();
             var verifier = CompileAndVerify(comp, expectedOutput: "42 - 42");
             verifier.VerifyIL("A.Deconstruct", @"
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/TopLevelStatementsTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/TopLevelStatementsTests.cs
index 1885bc63119c3..3f36753d91e4d 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/TopLevelStatementsTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/TopLevelStatementsTests.cs
@@ -8819,5 +8819,98 @@ void M()
     Statements (0)
 ");
         }
+
+        [Fact]
+        public void EmptyStatements_01()
+        {
+            var text = @";";
+
+            var comp = CreateCompilation(text, options: TestOptions.DebugExe, parseOptions: DefaultParseOptions);
+            comp.VerifyDiagnostics(
+                // (1,1): error CS8937: At least one top-level statement must be non-empty.
+                // ;
+                Diagnostic(ErrorCode.ERR_SimpleProgramIsEmpty, ";").WithLocation(1, 1)
+                );
+        }
+
+        [Fact]
+        public void EmptyStatements_02()
+        {
+            var text = @";;
+
+
+;;
+;";
+
+            var comp = CreateCompilation(text, options: TestOptions.DebugExe, parseOptions: DefaultParseOptions);
+            comp.VerifyDiagnostics(
+                // (1,1): error CS8937: At least one top-level statement must be non-empty.
+                // ;;
+                Diagnostic(ErrorCode.ERR_SimpleProgramIsEmpty, ";").WithLocation(1, 1)
+                );
+        }
+
+        [Fact]
+        public void EmptyStatements_03()
+        {
+            var text = @"
+System.Console.WriteLine(""Hi!"");
+;;
+;
+";
+
+            var comp = CreateCompilation(text, options: TestOptions.DebugExe, parseOptions: DefaultParseOptions);
+            CompileAndVerify(comp, expectedOutput: "Hi!");
+        }
+
+        [Fact]
+        public void EmptyStatements_04()
+        {
+            var text = @"
+;;
+;
+System.Console.WriteLine(""Hi!"");";
+
+            var comp = CreateCompilation(text, options: TestOptions.DebugExe, parseOptions: DefaultParseOptions);
+            CompileAndVerify(comp, expectedOutput: "Hi!");
+        }
+
+        [Fact]
+        public void EmptyStatements_05()
+        {
+            var text = @"
+;
+System.Console.WriteLine(""Hi!"");
+;
+";
+
+            var comp = CreateCompilation(text, options: TestOptions.DebugExe, parseOptions: DefaultParseOptions);
+            CompileAndVerify(comp, expectedOutput: "Hi!");
+        }
+
+        [Fact]
+        public void EmptyStatements_06()
+        {
+            var text =
+@"
+using System;
+;
+
+class Program
+{
+    static void Main(String[] args) {}
+}
+";
+
+            var comp = CreateCompilation(text, options: TestOptions.DebugExe, parseOptions: DefaultParseOptions);
+            comp.VerifyDiagnostics(
+                // (3,1): error CS8937: At least one top-level statement must be non-empty.
+                // ;
+                Diagnostic(ErrorCode.ERR_SimpleProgramIsEmpty, ";").WithLocation(3, 1),
+                // (7,17): warning CS7022: The entry point of the program is global code; ignoring 'Program.Main(string[])' entry point.
+                //     static void Main(String[] args) {}
+                Diagnostic(ErrorCode.WRN_MainIgnored, "Main").WithArguments("Program.Main(string[])").WithLocation(7, 17)
+                );
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/AdditionalSourcesCollectionTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/AdditionalSourcesCollectionTests.cs
index 0fc19de8955d3..b584b2349c3f8 100644
--- a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/AdditionalSourcesCollectionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/AdditionalSourcesCollectionTests.cs
@@ -74,7 +74,9 @@ public void HintName_WithExtension(string hintName)
         public void HintName_InvalidValues(string hintName)
         {
             AdditionalSourcesCollection asc = new AdditionalSourcesCollection(".cs");
-            Assert.Throws<ArgumentException>(nameof(hintName), () => asc.Add(hintName, SourceText.From("public class D{}", Encoding.UTF8)));
+            var exception = Assert.Throws<ArgumentException>(nameof(hintName), () => asc.Add(hintName, SourceText.From("public class D{}", Encoding.UTF8)));
+
+            Assert.Contains(hintName, exception.Message);
         }
 
         [Fact]
@@ -130,7 +132,9 @@ public void Hint_Name_Must_Be_Unique(string hintName1, string hintName2)
         {
             AdditionalSourcesCollection asc = new AdditionalSourcesCollection(".cs");
             asc.Add(hintName1, SourceText.From("", Encoding.UTF8));
-            Assert.Throws<ArgumentException>("hintName", () => asc.Add(hintName2, SourceText.From("", Encoding.UTF8)));
+            var exception = Assert.Throws<ArgumentException>("hintName", () => asc.Add(hintName2, SourceText.From("", Encoding.UTF8)));
+
+            Assert.Contains(hintName2, exception.Message);
         }
 
         [Theory]
@@ -179,6 +183,11 @@ public void SourceTextRequiresEncoding()
 
             // explicit null encoding
             Assert.Throws<ArgumentException>(() => asc.Add("file5.cs", SourceText.From("", encoding: null)));
+
+            var exception = Assert.Throws<ArgumentException>(() => asc.Add("file5.cs", SourceText.From("", encoding: null)));
+
+            // check the exception contains the expected hintName
+            Assert.Contains("file5.cs", exception.Message);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs
index 49a62ab5fc23f..dd7cbc2ce6ba1 100644
--- a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs
@@ -3,12 +3,14 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.CSharp.UnitTests;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -262,283 +264,6 @@ class C
             generatorDiagnostics.Verify();
         }
 
-        [Fact]
-        public void TryApply_Edits_Fails_If_FullGeneration_Has_Not_Run()
-        {
-            var source = @"
-class C { }
-";
-
-            var parseOptions = TestOptions.Regular;
-            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
-            compilation.VerifyDiagnostics();
-            Assert.Single(compilation.SyntaxTrees);
-
-            AdditionalFileAddedGenerator testGenerator = new AdditionalFileAddedGenerator() { CanApplyChanges = false };
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { testGenerator }, parseOptions: parseOptions);
-
-            // try apply edits should fail if we've not run a full compilation yet
-            driver = driver.TryApplyEdits(compilation, out var outputCompilation, out var succeeded);
-            Assert.False(succeeded);
-            Assert.Equal(compilation, outputCompilation);
-        }
-
-        [Fact]
-        public void TryApply_Edits_Does_Nothing_When_Nothing_Pending()
-        {
-            var source = @"
-class C { }
-";
-
-            var parseOptions = TestOptions.Regular;
-            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
-            compilation.VerifyDiagnostics();
-            Assert.Single(compilation.SyntaxTrees);
-
-            AdditionalFileAddedGenerator testGenerator = new AdditionalFileAddedGenerator();
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { testGenerator }, parseOptions: parseOptions);
-
-            // run an initial generation pass
-            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out _);
-            Assert.Single(outputCompilation.SyntaxTrees);
-
-            // now try apply edits (which should succeed, but do nothing)
-            driver = driver.TryApplyEdits(compilation, out var editedCompilation, out var succeeded);
-            Assert.True(succeeded);
-            Assert.Equal(outputCompilation, editedCompilation);
-        }
-
-        [Fact]
-        public void Failed_Edit_Does_Not_Change_Compilation()
-        {
-            var source = @"
-class C { }
-";
-
-            var parseOptions = TestOptions.Regular;
-            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
-            compilation.VerifyDiagnostics();
-            Assert.Single(compilation.SyntaxTrees);
-
-            AdditionalFileAddedGenerator testGenerator = new AdditionalFileAddedGenerator() { CanApplyChanges = false };
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { testGenerator }, parseOptions: parseOptions);
-
-            driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out _);
-            Assert.Single(outputCompilation.SyntaxTrees);
-
-            // create an edit
-            AdditionalFileAddedEdit edit = new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file2.cs", ""));
-            driver = driver.WithPendingEdits(ImmutableArray.Create<PendingEdit>(edit));
-
-            // now try apply edits (which will fail)
-            driver = driver.TryApplyEdits(compilation, out var editedCompilation, out var succeeded);
-            Assert.False(succeeded);
-            Assert.Single(editedCompilation.SyntaxTrees);
-            Assert.Equal(compilation, editedCompilation);
-        }
-
-        [Fact]
-        public void Added_Additional_File()
-        {
-            var source = @"
-class C { }
-";
-
-            var parseOptions = TestOptions.Regular;
-            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
-            compilation.VerifyDiagnostics();
-            Assert.Single(compilation.SyntaxTrees);
-
-            AdditionalFileAddedGenerator testGenerator = new AdditionalFileAddedGenerator();
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { testGenerator }, parseOptions: parseOptions);
-
-            // run initial generation pass
-            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out _);
-            Assert.Single(outputCompilation.SyntaxTrees);
-
-            // create an edit
-            AdditionalFileAddedEdit edit = new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file1.cs", ""));
-            driver = driver.WithPendingEdits(ImmutableArray.Create<PendingEdit>(edit));
-
-            // now try apply edits
-            driver = driver.TryApplyEdits(compilation, out outputCompilation, out var succeeded);
-            Assert.True(succeeded);
-            Assert.Equal(2, outputCompilation.SyntaxTrees.Count());
-        }
-
-        [Fact]
-        public void Multiple_Added_Additional_Files()
-        {
-            var source = @"
-class C { }
-";
-
-            var parseOptions = TestOptions.Regular;
-            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
-            compilation.VerifyDiagnostics();
-            Assert.Single(compilation.SyntaxTrees);
-
-            AdditionalFileAddedGenerator testGenerator = new AdditionalFileAddedGenerator();
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(parseOptions: parseOptions,
-                                                                  generators: ImmutableArray.Create<ISourceGenerator>(testGenerator),
-                                                                  optionsProvider: CompilerAnalyzerConfigOptionsProvider.Empty,
-                                                                  additionalTexts: ImmutableArray.Create<AdditionalText>(new InMemoryAdditionalText("a\\file1.cs", "")));
-
-            // run initial generation pass
-            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out _);
-            Assert.Equal(2, outputCompilation.SyntaxTrees.Count());
-
-            // create an edit
-            AdditionalFileAddedEdit edit = new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file2.cs", ""));
-            driver = driver.WithPendingEdits(ImmutableArray.Create<PendingEdit>(edit));
-
-            // now try apply edits
-            driver = driver.TryApplyEdits(compilation, out var editedCompilation, out var succeeded);
-            Assert.True(succeeded);
-            Assert.Equal(3, editedCompilation.SyntaxTrees.Count());
-
-            // if we run a full compilation again, we should still get 3 syntax trees
-            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out outputCompilation, out _);
-            Assert.Equal(3, outputCompilation.SyntaxTrees.Count());
-
-            // lets add multiple edits   
-            driver = driver.WithPendingEdits(ImmutableArray.Create<PendingEdit>(new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file3.cs", "")),
-                                                                                new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file4.cs", "")),
-                                                                                new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file5.cs", ""))));
-            // now try apply edits
-            driver = driver.TryApplyEdits(compilation, out editedCompilation, out succeeded);
-            Assert.True(succeeded);
-            Assert.Equal(6, editedCompilation.SyntaxTrees.Count());
-        }
-
-        [Fact]
-        public void Added_Additional_File_With_Full_Generation()
-        {
-            var source = @"
-class C { }
-";
-
-            var parseOptions = TestOptions.Regular;
-            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
-            compilation.VerifyDiagnostics();
-            Assert.Single(compilation.SyntaxTrees);
-
-            AdditionalFileAddedGenerator testGenerator = new AdditionalFileAddedGenerator();
-            var text = new InMemoryAdditionalText("a\\file1.cs", "");
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(parseOptions: parseOptions,
-                                                                  generators: ImmutableArray.Create<ISourceGenerator>(testGenerator),
-                                                                  optionsProvider: CompilerAnalyzerConfigOptionsProvider.Empty,
-                                                                  additionalTexts: ImmutableArray.Create<AdditionalText>(new InMemoryAdditionalText("a\\file1.cs", "")));
-
-            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out _);
-
-            // we should have a single extra file for the additional texts
-            Assert.Equal(2, outputCompilation.SyntaxTrees.Count());
-
-            // even if we run a full gen, or partial, nothing should change yet
-            driver = driver.TryApplyEdits(outputCompilation, out var editedCompilation, out var succeeded);
-            Assert.True(succeeded);
-            Assert.Equal(2, editedCompilation.SyntaxTrees.Count());
-
-            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out outputCompilation, out _);
-            Assert.Equal(2, outputCompilation.SyntaxTrees.Count());
-
-            // create an edit
-            AdditionalFileAddedEdit edit = new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file2.cs", ""));
-            driver = driver.WithPendingEdits(ImmutableArray.Create<PendingEdit>(edit));
-
-            // now try apply edits
-            driver = driver.TryApplyEdits(compilation, out editedCompilation, out succeeded);
-            Assert.True(succeeded);
-            Assert.Equal(3, editedCompilation.SyntaxTrees.Count());
-
-            // if we run a full compilation again, we should still get 3 syntax trees
-            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out outputCompilation, out _);
-            Assert.Equal(3, outputCompilation.SyntaxTrees.Count());
-        }
-
-        [Fact]
-        public void Edits_Are_Applied_During_Full_Generation()
-        {
-            var source = @"
-class C { }
-";
-
-            var parseOptions = TestOptions.Regular;
-            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
-            compilation.VerifyDiagnostics();
-            Assert.Single(compilation.SyntaxTrees);
-
-            AdditionalFileAddedGenerator testGenerator = new AdditionalFileAddedGenerator();
-            var text = new InMemoryAdditionalText("a\\file1.cs", "");
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(parseOptions: parseOptions,
-                                                                  generators: ImmutableArray.Create<ISourceGenerator>(testGenerator),
-                                                                  optionsProvider: CompilerAnalyzerConfigOptionsProvider.Empty,
-                                                                  additionalTexts: ImmutableArray.Create<AdditionalText>(new InMemoryAdditionalText("a\\file1.cs", "")));
-
-            driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out _);
-            Assert.Equal(2, outputCompilation.SyntaxTrees.Count());
-
-            // add multiple edits   
-            driver = driver.WithPendingEdits(ImmutableArray.Create<PendingEdit>(new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file2.cs", "")),
-                                                                                new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file3.cs", "")),
-                                                                                new AdditionalFileAddedEdit(new InMemoryAdditionalText("a\\file4.cs", ""))));
-
-            // but just do a full generation (don't try apply)
-            driver.RunGeneratorsAndUpdateCompilation(compilation, out outputCompilation, out _);
-            Assert.Equal(5, outputCompilation.SyntaxTrees.Count());
-        }
-
-        [Fact]
-        public void Adding_Another_Generator_Makes_TryApplyEdits_Fail()
-        {
-            var source = @"
-class C { }
-";
-
-            var parseOptions = TestOptions.Regular;
-            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
-            compilation.VerifyDiagnostics();
-            Assert.Single(compilation.SyntaxTrees);
-
-            SingleFileTestGenerator testGenerator1 = new SingleFileTestGenerator("public class D { }");
-            SingleFileTestGenerator2 testGenerator2 = new SingleFileTestGenerator2("public class E { }");
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(parseOptions: parseOptions,
-                                                                  generators: ImmutableArray.Create<ISourceGenerator>(testGenerator1),
-                                                                  optionsProvider: CompilerAnalyzerConfigOptionsProvider.Empty,
-                                                                  additionalTexts: ImmutableArray<AdditionalText>.Empty);
-
-            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out _);
-            Assert.Equal(2, outputCompilation.SyntaxTrees.Count());
-
-            // try apply edits
-            driver = driver.TryApplyEdits(compilation, out _, out bool success);
-            Assert.True(success);
-
-            // add another generator
-            driver = driver.AddGenerators(ImmutableArray.Create<ISourceGenerator>(testGenerator2));
-
-            // try apply changes should now fail
-            driver = driver.TryApplyEdits(compilation, out _, out success);
-            Assert.False(success);
-
-            // full generation
-            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out outputCompilation, out _);
-            Assert.Equal(3, outputCompilation.SyntaxTrees.Count());
-
-            // try apply changes should now succeed
-            driver.TryApplyEdits(compilation, out _, out success);
-            Assert.True(success);
-        }
-
         [Fact]
         public void Error_During_Initialization_Is_Reported()
         {
@@ -731,7 +456,7 @@ class C { }
                 );
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/54185: the addition happens later so the execeptions don't occur directly at add-time. we should decide if this subtle behavior change is acceptable")]
         public void Generator_HintName_MustBe_Unique()
         {
             var source = @"
@@ -953,42 +678,6 @@ class C { }
             AssertEx.Equal(results.Diagnostics, fullDiagnostics);
         }
 
-        [Fact]
-        public void Cancellation_During_Initialization_Doesnt_Report_As_Generator_Error()
-        {
-            var source = @"
-class C 
-{
-}
-";
-            var parseOptions = TestOptions.Regular;
-            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
-            compilation.VerifyDiagnostics();
-
-            Assert.Single(compilation.SyntaxTrees);
-
-            CancellationTokenSource cts = new CancellationTokenSource();
-
-            var testGenerator = new CallbackGenerator(
-                onInit: (i) => { cts.Cancel(); },
-                onExecute: (e) => { }
-                );
-
-            // test generator cancels the token. Check that the call to this generator doesn't make it look like it errored.
-            var testGenerator2 = new CallbackGenerator2(
-                onInit: (i) => { i.CancellationToken.ThrowIfCancellationRequested(); },
-                onExecute: (e) => { throw ExceptionUtilities.Unreachable; });
-
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { testGenerator, testGenerator2 }, parseOptions: parseOptions);
-            var oldDriver = driver;
-
-            Assert.Throws<OperationCanceledException>(() =>
-               driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var outputDiagnostics, cts.Token)
-               );
-            Assert.Same(oldDriver, driver);
-        }
-
         [Fact]
         public void Cancellation_During_Execution_Doesnt_Report_As_Generator_Error()
         {
@@ -1047,7 +736,7 @@ class C { }
 
             Assert.Single(outputDiagnostics);
             outputDiagnostics.Verify(
-                Diagnostic("CS" + (int)ErrorCode.WRN_GeneratorFailedDuringGeneration).WithArguments("CallbackGenerator", "ArgumentException", "The provided SourceText must have an explicit encoding set. (Parameter 'source')").WithLocation(1, 1)
+                Diagnostic("CS" + (int)ErrorCode.WRN_GeneratorFailedDuringGeneration).WithArguments("CallbackGenerator", "ArgumentException", "The SourceText with hintName 'a.cs' must have an explicit encoding set. (Parameter 'source')").WithLocation(1, 1)
                 );
         }
 
@@ -1076,6 +765,67 @@ class C
             Assert.Same(parseOptions, passedOptions);
         }
 
+        [Fact]
+        public void AdditionalFiles_Are_Passed_To_Generator()
+        {
+            var source = @"
+class C 
+{
+}
+";
+            var parseOptions = TestOptions.Regular;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+            Assert.Single(compilation.SyntaxTrees);
+
+            var texts = ImmutableArray.Create<AdditionalText>(new InMemoryAdditionalText("a", "abc"), new InMemoryAdditionalText("b", "def"));
+
+            ImmutableArray<AdditionalText> passedIn = default;
+            var testGenerator = new CallbackGenerator(
+                onInit: (i) => { },
+                onExecute: (e) => passedIn = e.AdditionalFiles
+                );
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { testGenerator }, parseOptions: parseOptions, additionalTexts: texts);
+            driver.RunGeneratorsAndUpdateCompilation(compilation, out _, out _);
+
+            Assert.Equal(2, passedIn.Length);
+            Assert.Equal<AdditionalText>(texts, passedIn);
+        }
+
+        [Fact]
+        public void AnalyzerConfigOptions_Are_Passed_To_Generator()
+        {
+            var source = @"
+class C 
+{
+}
+";
+            var parseOptions = TestOptions.Regular;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+            Assert.Single(compilation.SyntaxTrees);
+
+            var options = new CompilerAnalyzerConfigOptionsProvider(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, new CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("a", "abc").Add("b", "def")));
+
+            AnalyzerConfigOptionsProvider? passedIn = null;
+            var testGenerator = new CallbackGenerator(
+                onInit: (i) => { },
+                onExecute: (e) => passedIn = e.AnalyzerConfigOptions
+                );
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { testGenerator }, parseOptions: parseOptions, optionsProvider: options);
+            driver.RunGeneratorsAndUpdateCompilation(compilation, out _, out _);
+
+            Assert.NotNull(passedIn);
+
+            Assert.True(passedIn!.GlobalOptions.TryGetValue("a", out var item1));
+            Assert.Equal("abc", item1);
+
+            Assert.True(passedIn!.GlobalOptions.TryGetValue("b", out var item2));
+            Assert.Equal("def", item2);
+        }
+
         [Fact]
         public void Generator_Can_Provide_Source_In_PostInit()
         {
@@ -1491,5 +1241,760 @@ void verifyDiagnosticsWithSource(string source, (Diagnostic, TextSpan)[] reportD
                 diagnostics.Verify(expected);
             }
         }
+
+        [Theory]
+        [InlineData(LanguageVersion.CSharp9)]
+        [InlineData(LanguageVersion.CSharp10)]
+        [InlineData(LanguageVersion.Preview)]
+        public void GeneratorDriver_Prefers_Incremental_Generators(LanguageVersion langVer)
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.Regular.WithLanguageVersion(langVer);
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            int initCount = 0, executeCount = 0;
+            var generator = new CallbackGenerator((ic) => initCount++, (sgc) => executeCount++);
+
+            int incrementalInitCount = 0;
+            var generator2 = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ic) => incrementalInitCount++));
+
+            int dualInitCount = 0, dualExecuteCount = 0, dualIncrementalInitCount = 0;
+            var generator3 = new IncrementalAndSourceCallbackGenerator((ic) => dualInitCount++, (sgc) => dualExecuteCount++, (ic) => dualIncrementalInitCount++);
+
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator, generator2, generator3 }, parseOptions: parseOptions);
+            driver.RunGenerators(compilation);
+
+            // ran generator 1 always
+            Assert.Equal(1, initCount);
+            Assert.Equal(1, executeCount);
+
+            // ran the incremental generator if in preview
+            Assert.Equal(langVer == LanguageVersion.Preview ? 1 : 0, incrementalInitCount);
+
+            // ran the combined generator only as an IIncrementalGenerator if in preview, or as an ISourceGenerator when not
+            Assert.Equal(langVer == LanguageVersion.Preview ? 0 : 1, dualInitCount);
+            Assert.Equal(langVer == LanguageVersion.Preview ? 0 : 1, dualExecuteCount);
+            Assert.Equal(langVer == LanguageVersion.Preview ? 1 : 0, dualIncrementalInitCount);
+        }
+
+        [Theory]
+        [InlineData(LanguageVersion.CSharp9)]
+        [InlineData(LanguageVersion.CSharp10)]
+        [InlineData(LanguageVersion.Preview)]
+        public void GeneratorDriver_Initializes_Incremental_Generators(LanguageVersion langVer)
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.Regular.WithLanguageVersion(langVer);
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            int incrementalInitCount = 0;
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ic) => incrementalInitCount++));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver.RunGenerators(compilation);
+
+            // ran the incremental generator
+            Assert.Equal((langVer == LanguageVersion.Preview) ? 1 : 0, incrementalInitCount);
+        }
+
+        [Fact]
+        public void Incremental_Generators_Exception_During_Initialization()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var e = new InvalidOperationException("abc");
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ic) => throw e));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            var runResults = driver.GetRunResult();
+
+            Assert.Single(runResults.Diagnostics);
+            Assert.Single(runResults.Results);
+            Assert.Empty(runResults.GeneratedTrees);
+            Assert.Equal(e, runResults.Results[0].Exception);
+        }
+
+        [Fact]
+        public void Incremental_Generators_Exception_During_Execution()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var e = new InvalidOperationException("abc");
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ctx) => ctx.RegisterSourceOutput(ctx.CompilationProvider, (spc, c) => throw e)));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            var runResults = driver.GetRunResult();
+
+            Assert.Single(runResults.Diagnostics);
+            Assert.Single(runResults.Results);
+            Assert.Empty(runResults.GeneratedTrees);
+            Assert.Equal(e, runResults.Results[0].Exception);
+        }
+
+        [Fact]
+        public void Incremental_Generators_Exception_During_Execution_Doesnt_Produce_AnySource()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var e = new InvalidOperationException("abc");
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ctx) =>
+            {
+                ctx.RegisterSourceOutput(ctx.CompilationProvider, (spc, c) => spc.AddSource("test", ""));
+                ctx.RegisterSourceOutput(ctx.CompilationProvider, (spc, c) => throw e);
+            }));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            var runResults = driver.GetRunResult();
+
+            Assert.Single(runResults.Diagnostics);
+            Assert.Single(runResults.Results);
+            Assert.Empty(runResults.GeneratedTrees);
+            Assert.Equal(e, runResults.Results[0].Exception);
+        }
+
+        [Fact]
+        public void Incremental_Generators_Exception_During_Execution_Doesnt_Stop_Other_Generators()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var e = new InvalidOperationException("abc");
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ctx) =>
+            {
+                ctx.RegisterSourceOutput(ctx.CompilationProvider, (spc, c) => throw e);
+            }));
+
+            var generator2 = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator2((ctx) =>
+            {
+                ctx.RegisterSourceOutput(ctx.CompilationProvider, (spc, c) => spc.AddSource("test", ""));
+            }));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator, generator2 }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            var runResults = driver.GetRunResult();
+
+            Assert.Single(runResults.Diagnostics);
+            Assert.Equal(2, runResults.Results.Length);
+            Assert.Single(runResults.GeneratedTrees);
+            Assert.Equal(e, runResults.Results[0].Exception);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_No_Pipeline_Callback_Is_Valid()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ic) => { }));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var diagnostics);
+
+            outputCompilation.VerifyDiagnostics();
+            Assert.Empty(diagnostics);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_Can_Add_PostInit_Source()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ic) => ic.RegisterPostInitializationOutput(c => c.AddSource("a", "class D {}"))));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var diagnostics);
+
+            Assert.Equal(2, outputCompilation.SyntaxTrees.Count());
+            Assert.Empty(diagnostics);
+        }
+
+        [Fact]
+        public void User_WrappedFunc_Throw_Exceptions()
+        {
+            Func<int, CancellationToken, int> func = (input, _) => input;
+            Func<int, CancellationToken, int> throwsFunc = (input, _) => throw new InvalidOperationException("user code exception");
+            Func<int, CancellationToken, int> timeoutFunc = (input, ct) => { ct.ThrowIfCancellationRequested(); return input; };
+            Func<int, CancellationToken, int> otherTimeoutFunc = (input, _) => throw new OperationCanceledException();
+
+            var userFunc = func.WrapUserFunction();
+            var userThrowsFunc = throwsFunc.WrapUserFunction();
+            var userTimeoutFunc = timeoutFunc.WrapUserFunction();
+            var userOtherTimeoutFunc = otherTimeoutFunc.WrapUserFunction();
+
+            // user functions return same values when wrapped
+            var result = userFunc(10, CancellationToken.None);
+            var userResult = userFunc(10, CancellationToken.None);
+            Assert.Equal(10, result);
+            Assert.Equal(result, userResult);
+
+            // exceptions thrown in user code are wrapped
+            Assert.Throws<InvalidOperationException>(() => throwsFunc(20, CancellationToken.None));
+            Assert.Throws<UserFunctionException>(() => userThrowsFunc(20, CancellationToken.None));
+
+            try
+            {
+                userThrowsFunc(20, CancellationToken.None);
+            }
+            catch (UserFunctionException e)
+            {
+                Assert.IsType<InvalidOperationException>(e.InnerException);
+            }
+
+            // cancellation is not wrapped, and is bubbled up
+            Assert.Throws<OperationCanceledException>(() => timeoutFunc(30, new CancellationToken(true)));
+            Assert.Throws<OperationCanceledException>(() => userTimeoutFunc(30, new CancellationToken(true)));
+
+            // unless it wasn't *our* cancellation token, in which case it still gets wrapped
+            Assert.Throws<OperationCanceledException>(() => otherTimeoutFunc(30, CancellationToken.None));
+            Assert.Throws<UserFunctionException>(() => userOtherTimeoutFunc(30, CancellationToken.None));
+        }
+
+        [Fact]
+        public void IncrementalGenerator_Doesnt_Run_For_Same_Input()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            List<Compilation> compilationsCalledFor = new List<Compilation>();
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                var filePaths = ctx.CompilationProvider.SelectMany((c, _) => c.SyntaxTrees).Select((tree, _) => tree.FilePath);
+
+                ctx.RegisterSourceOutput(ctx.CompilationProvider, (spc, c) => { compilationsCalledFor.Add(c); });
+            }));
+
+            // run the generator once, and check it was passed the compilation
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(1, compilationsCalledFor.Count);
+            Assert.Equal(compilation, compilationsCalledFor[0]);
+
+            // run the same compilation through again, and confirm the output wasn't called
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(1, compilationsCalledFor.Count);
+            Assert.Equal(compilation, compilationsCalledFor[0]);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_Runs_Only_For_Changed_Inputs()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var text1 = new InMemoryAdditionalText("Text1", "content1");
+            var text2 = new InMemoryAdditionalText("Text2", "content2");
+
+            List<Compilation> compilationsCalledFor = new List<Compilation>();
+            List<AdditionalText> textsCalledFor = new List<AdditionalText>();
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                ctx.RegisterSourceOutput(ctx.CompilationProvider, (spc, c) => { compilationsCalledFor.Add(c); });
+
+                ctx.RegisterSourceOutput(ctx.AdditionalTextsProvider, (spc, c) => { textsCalledFor.Add(c); });
+            }));
+
+            // run the generator once, and check it was passed the compilation
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, additionalTexts: new[] { text1 }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(1, compilationsCalledFor.Count);
+            Assert.Equal(compilation, compilationsCalledFor[0]);
+            Assert.Equal(1, textsCalledFor.Count);
+            Assert.Equal(text1, textsCalledFor[0]);
+
+            // clear the results, add an additional text, but keep the compilation the same
+            compilationsCalledFor.Clear();
+            textsCalledFor.Clear();
+            driver = driver.AddAdditionalTexts(ImmutableArray.Create<AdditionalText>(text2));
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(0, compilationsCalledFor.Count);
+            Assert.Equal(1, textsCalledFor.Count);
+            Assert.Equal(text2, textsCalledFor[0]);
+
+            // now edit the compilation
+            compilationsCalledFor.Clear();
+            textsCalledFor.Clear();
+            var newCompilation = compilation.WithOptions(compilation.Options.WithModuleName("newComp"));
+            driver = driver.RunGenerators(newCompilation);
+            Assert.Equal(1, compilationsCalledFor.Count);
+            Assert.Equal(newCompilation, compilationsCalledFor[0]);
+            Assert.Equal(0, textsCalledFor.Count);
+
+            // re run without changing anything
+            compilationsCalledFor.Clear();
+            textsCalledFor.Clear();
+            driver = driver.RunGenerators(newCompilation);
+            Assert.Equal(0, compilationsCalledFor.Count);
+            Assert.Equal(0, textsCalledFor.Count);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_Can_Add_Comparer_To_Input_Node()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            List<Compilation> compilationsCalledFor = new List<Compilation>();
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                var compilationSource = ctx.CompilationProvider.WithComparer(new LambdaComparer<Compilation>((c1, c2) => true, 0));
+                ctx.RegisterSourceOutput(compilationSource, (spc, c) =>
+                {
+                    compilationsCalledFor.Add(c);
+                });
+            }));
+
+            // run the generator once, and check it was passed the compilation
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(1, compilationsCalledFor.Count);
+            Assert.Equal(compilation, compilationsCalledFor[0]);
+
+            // now edit the compilation, run the generator, and confirm that the output was not called again this time
+            Compilation newCompilation = compilation.WithOptions(compilation.Options.WithModuleName("newCompilation"));
+            driver = driver.RunGenerators(newCompilation);
+            Assert.Equal(1, compilationsCalledFor.Count);
+            Assert.Equal(compilation, compilationsCalledFor[0]);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_Can_Add_Comparer_To_Combine_Node()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            List<AdditionalText> texts = new List<AdditionalText>() { new InMemoryAdditionalText("abc", "") };
+
+            List<(Compilation, ImmutableArray<AdditionalText>)> calledFor = new List<(Compilation, ImmutableArray<AdditionalText>)>();
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                var compilationSource = ctx.CompilationProvider.Combine(ctx.AdditionalTextsProvider.Collect())
+                                                // comparer that ignores the LHS (additional texts)
+                                                .WithComparer(new LambdaComparer<(Compilation, ImmutableArray<AdditionalText>)>((c1, c2) => c1.Item1 == c2.Item1, 0));
+                ctx.RegisterSourceOutput(compilationSource, (spc, c) =>
+                {
+                    calledFor.Add(c);
+                });
+            }));
+
+            // run the generator once, and check it was passed the compilation + additional texts
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions, additionalTexts: texts);
+            driver = driver.RunGenerators(compilation);
+
+            Assert.Equal(1, calledFor.Count);
+            Assert.Equal(compilation, calledFor[0].Item1);
+            Assert.Equal(texts[0], calledFor[0].Item2.Single());
+
+            // edit the additional texts, and verify that the output was *not* called again on the next run
+            driver = driver.RemoveAdditionalTexts(texts.ToImmutableArray());
+            driver = driver.RunGenerators(compilation);
+
+            Assert.Equal(1, calledFor.Count);
+
+            // now edit the compilation, run the generator, and confirm that the output *was* called again this time with the new compilation and no additional texts
+            Compilation newCompilation = compilation.WithOptions(compilation.Options.WithModuleName("newCompilation"));
+            driver = driver.RunGenerators(newCompilation);
+            Assert.Equal(2, calledFor.Count);
+            Assert.Equal(newCompilation, calledFor[1].Item1);
+            Assert.Empty(calledFor[1].Item2);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_Register_End_Node_Only_Once_Through_Combines()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            List<Compilation> compilationsCalledFor = new List<Compilation>();
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                var source = ctx.CompilationProvider;
+                var source2 = ctx.CompilationProvider.Combine(source);
+                var source3 = ctx.CompilationProvider.Combine(source2);
+                var source4 = ctx.CompilationProvider.Combine(source3);
+                var source5 = ctx.CompilationProvider.Combine(source4);
+
+                ctx.RegisterSourceOutput(source5, (spc, c) =>
+                {
+                    compilationsCalledFor.Add(c.Item1);
+                });
+            }));
+
+            // run the generator and check that we didn't multiple register the generate source node through the combine
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(1, compilationsCalledFor.Count);
+            Assert.Equal(compilation, compilationsCalledFor[0]);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_PostInit_Source_Is_Cached()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            List<ClassDeclarationSyntax> classes = new List<ClassDeclarationSyntax>();
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ctx) =>
+            {
+                ctx.RegisterPostInitializationOutput(c => c.AddSource("a", "class D {}"));
+
+                ctx.RegisterSourceOutput(ctx.SyntaxProvider.CreateSyntaxProvider(static (n, _) => n is ClassDeclarationSyntax, (gsc, _) => (ClassDeclarationSyntax)gsc.Node), (spc, node) => classes.Add(node));
+            }));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            Assert.Equal(2, classes.Count);
+            Assert.Equal("C", classes[0].Identifier.ValueText);
+            Assert.Equal("D", classes[1].Identifier.ValueText);
+
+            // clear classes, re-run
+            classes.Clear();
+            driver = driver.RunGenerators(compilation);
+            Assert.Empty(classes);
+
+            // modify the original tree, see that the post init is still cached
+            var c2 = compilation.ReplaceSyntaxTree(compilation.SyntaxTrees.First(), CSharpSyntaxTree.ParseText("class E{}", parseOptions));
+            classes.Clear();
+            driver = driver.RunGenerators(c2);
+            Assert.Single(classes);
+            Assert.Equal("E", classes[0].Identifier.ValueText);
+        }
+
+        [Fact]
+        public void Incremental_Generators_Can_Be_Cancelled()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            CancellationTokenSource cts = new CancellationTokenSource();
+            bool generatorCancelled = false;
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ctx) =>
+            {
+                var step1 = ctx.CompilationProvider.Select((c, ct) => { generatorCancelled = true; cts.Cancel(); return c; });
+                var step2 = step1.Select((c, ct) => { ct.ThrowIfCancellationRequested(); return c; });
+
+                ctx.RegisterSourceOutput(step2, (spc, c) => spc.AddSource("a", ""));
+            }));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            Assert.Throws<OperationCanceledException>(() => driver = driver.RunGenerators(compilation, cancellationToken: cts.Token));
+            Assert.True(generatorCancelled);
+        }
+
+        [Fact]
+        public void ParseOptions_Can_Be_Updated()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            List<ParseOptions> parseOptionsCalledFor = new List<ParseOptions>();
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                ctx.RegisterSourceOutput(ctx.ParseOptionsProvider, (spc, p) => { parseOptionsCalledFor.Add(p); });
+            }));
+
+            // run the generator once, and check it was passed the parse options
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(1, parseOptionsCalledFor.Count);
+            Assert.Equal(parseOptions, parseOptionsCalledFor[0]);
+
+            // clear the results, and re-run
+            parseOptionsCalledFor.Clear();
+            driver = driver.RunGenerators(compilation);
+            Assert.Empty(parseOptionsCalledFor);
+
+            // now update the parse options
+            parseOptionsCalledFor.Clear();
+            var newParseOptions = parseOptions.WithDocumentationMode(DocumentationMode.Diagnose);
+            driver = driver.WithUpdatedParseOptions(newParseOptions);
+
+            // check we ran
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(1, parseOptionsCalledFor.Count);
+            Assert.Equal(newParseOptions, parseOptionsCalledFor[0]);
+
+            // clear the results, and re-run
+            parseOptionsCalledFor.Clear();
+            driver = driver.RunGenerators(compilation);
+            Assert.Empty(parseOptionsCalledFor);
+
+            // replace it with null, and check that it throws
+            Assert.Throws<ArgumentNullException>(() => driver.WithUpdatedParseOptions(null!));
+        }
+
+        [Fact]
+        public void AnalyzerConfig_Can_Be_Updated()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+            string? analyzerOptionsValue = string.Empty;
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                ctx.RegisterSourceOutput(ctx.AnalyzerConfigOptionsProvider, (spc, p) => p.GlobalOptions.TryGetValue("test", out analyzerOptionsValue));
+            }));
+
+            var builder = ImmutableDictionary<string, string>.Empty.ToBuilder();
+            builder.Add("test", "value1");
+            var optionsProvider = new CompilerAnalyzerConfigOptionsProvider(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, new CompilerAnalyzerConfigOptions(builder.ToImmutable()));
+
+            // run the generator once, and check it was passed the configs
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions, optionsProvider: optionsProvider);
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal("value1", analyzerOptionsValue);
+
+            // clear the results, and re-run
+            analyzerOptionsValue = null;
+            driver = driver.RunGenerators(compilation);
+            Assert.Null(analyzerOptionsValue);
+
+            // now update the config
+            analyzerOptionsValue = null;
+            builder.Clear();
+            builder.Add("test", "value2");
+            var newOptionsProvider = optionsProvider.WithGlobalOptions(new CompilerAnalyzerConfigOptions(builder.ToImmutable()));
+            driver = driver.WithUpdatedAnalyzerConfigOptions(newOptionsProvider);
+
+            // check we ran
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal("value2", analyzerOptionsValue);
+
+            // replace it with null, and check that it throws
+            Assert.Throws<ArgumentNullException>(() => driver.WithUpdatedAnalyzerConfigOptions(null!));
+        }
+
+        [Fact]
+        public void AdditionalText_Can_Be_Replaced()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+            Assert.Single(compilation.SyntaxTrees);
+
+            InMemoryAdditionalText additionalText1 = new InMemoryAdditionalText("path1.txt", "");
+            InMemoryAdditionalText additionalText2 = new InMemoryAdditionalText("path2.txt", "");
+            InMemoryAdditionalText additionalText3 = new InMemoryAdditionalText("path3.txt", "");
+
+
+            List<string?> additionalTextPaths = new List<string?>();
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                ctx.RegisterSourceOutput(ctx.AdditionalTextsProvider.Select((t, _) => t.Path), (spc, p) => { additionalTextPaths.Add(p); });
+            }));
+
+            // run the generator once and check we saw the additional file
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions, additionalTexts: new[] { additionalText1, additionalText2, additionalText3 });
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(3, additionalTextPaths.Count);
+            Assert.Equal("path1.txt", additionalTextPaths[0]);
+            Assert.Equal("path2.txt", additionalTextPaths[1]);
+            Assert.Equal("path3.txt", additionalTextPaths[2]);
+
+            // re-run and check nothing else got added
+            additionalTextPaths.Clear();
+            driver = driver.RunGenerators(compilation);
+            Assert.Empty(additionalTextPaths);
+
+            // now, update the additional text, but keep the path the same
+            additionalTextPaths.Clear();
+            driver = driver.ReplaceAdditionalText(additionalText2, new InMemoryAdditionalText("path4.txt", ""));
+
+            // run, and check that only the replaced file was invoked
+            driver = driver.RunGenerators(compilation);
+            Assert.Single(additionalTextPaths);
+            Assert.Equal("path4.txt", additionalTextPaths[0]);
+
+            // replace it with null, and check that it throws
+            Assert.Throws<ArgumentNullException>(() => driver.ReplaceAdditionalText(additionalText1, null!));
+        }
+
+        [Fact]
+        public void Replaced_Input_Is_Treated_As_Modified()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+            Assert.Single(compilation.SyntaxTrees);
+
+            InMemoryAdditionalText additionalText = new InMemoryAdditionalText("path.txt", "abc");
+
+            List<string?> additionalTextPaths = new List<string?>();
+            List<string?> additionalTextsContents = new List<string?>();
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                var texts = ctx.AdditionalTextsProvider;
+                var paths = texts.Select((t, _) => t?.Path);
+                var contents = texts.Select((t, _) => t?.GetText()?.ToString());
+
+                ctx.RegisterSourceOutput(paths, (spc, p) => { additionalTextPaths.Add(p); });
+                ctx.RegisterSourceOutput(contents, (spc, p) => { additionalTextsContents.Add(p); });
+            }));
+
+            // run the generator once and check we saw the additional file
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions, additionalTexts: new[] { additionalText });
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(1, additionalTextPaths.Count);
+            Assert.Equal("path.txt", additionalTextPaths[0]);
+
+            Assert.Equal(1, additionalTextsContents.Count);
+            Assert.Equal("abc", additionalTextsContents[0]);
+
+            // re-run and check nothing else got added
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(1, additionalTextPaths.Count);
+            Assert.Equal(1, additionalTextsContents.Count);
+
+            // now, update the additional text, but keep the path the same
+            additionalTextPaths.Clear();
+            additionalTextsContents.Clear();
+            var secondText = new InMemoryAdditionalText("path.txt", "def");
+            driver = driver.ReplaceAdditionalText(additionalText, secondText);
+
+            // run, and check that only the contents got re-run
+            driver = driver.RunGenerators(compilation);
+            Assert.Empty(additionalTextPaths);
+
+            Assert.Equal(1, additionalTextsContents.Count);
+            Assert.Equal("def", additionalTextsContents[0]);
+
+            // now replace the text with a different path, but the same text
+            additionalTextPaths.Clear();
+            additionalTextsContents.Clear();
+            var thirdText = new InMemoryAdditionalText("path2.txt", "def");
+            driver = driver.ReplaceAdditionalText(secondText, thirdText);
+
+            // run, and check that only the paths got re-run
+            driver = driver.RunGenerators(compilation);
+
+            Assert.Equal(1, additionalTextPaths.Count);
+            Assert.Equal("path2.txt", additionalTextPaths[0]);
+
+            Assert.Empty(additionalTextsContents);
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/StateTableTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/StateTableTests.cs
new file mode 100644
index 0000000000000..2a86998678c58
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/StateTableTests.cs
@@ -0,0 +1,344 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests.SourceGeneration
+{
+    public class StateTableTests
+    {
+        [Fact]
+        public void Node_Table_Entries_Can_Be_Enumerated()
+        {
+            var builder = NodeStateTable<int>.Empty.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(1), EntryState.Added);
+            builder.AddEntries(ImmutableArray.Create(2), EntryState.Added);
+            builder.AddEntries(ImmutableArray.Create(3), EntryState.Added);
+            var table = builder.ToImmutableAndFree();
+
+            var expected = ImmutableArray.Create((1, EntryState.Added), (2, EntryState.Added), (3, EntryState.Added));
+            AssertTableEntries(table, expected);
+        }
+
+        [Fact]
+        public void Node_Table_Entries_Are_Flattened_When_Enumerated()
+        {
+            var builder = NodeStateTable<int>.Empty.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Added);
+            builder.AddEntries(ImmutableArray.Create(4, 5, 6), EntryState.Added);
+            builder.AddEntries(ImmutableArray.Create(7, 8, 9), EntryState.Added);
+            var table = builder.ToImmutableAndFree();
+
+            var expected = ImmutableArray.Create((1, EntryState.Added), (2, EntryState.Added), (3, EntryState.Added), (4, EntryState.Added), (5, EntryState.Added), (6, EntryState.Added), (7, EntryState.Added), (8, EntryState.Added), (9, EntryState.Added));
+            AssertTableEntries(table, expected);
+        }
+
+        [Fact]
+        public void Node_Table_Entries_Can_Be_The_Same_Object()
+        {
+            var o = new object();
+
+            var builder = NodeStateTable<object>.Empty.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(o, o, o), EntryState.Added);
+            var table = builder.ToImmutableAndFree();
+
+            var expected = ImmutableArray.Create((o, EntryState.Added), (o, EntryState.Added), (o, EntryState.Added));
+            AssertTableEntries(table, expected);
+        }
+
+        [Fact]
+        public void Node_Table_Entries_Can_Be_Null()
+        {
+            object? o = new object();
+
+            var builder = NodeStateTable<object?>.Empty.ToBuilder();
+            builder.AddEntry(o, EntryState.Added);
+            builder.AddEntry(null, EntryState.Added);
+            builder.AddEntry(o, EntryState.Added);
+            var table = builder.ToImmutableAndFree();
+
+            var expected = ImmutableArray.Create((o, EntryState.Added), (null, EntryState.Added), (o, EntryState.Added));
+            AssertTableEntries(table, expected);
+        }
+
+        [Fact]
+        public void Node_Builder_Can_Add_Entries_From_Previous_Table()
+        {
+            var builder = NodeStateTable<int>.Empty.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(1), EntryState.Added);
+            builder.AddEntries(ImmutableArray.Create(2, 3), EntryState.Cached);
+            builder.AddEntries(ImmutableArray.Create(4, 5), EntryState.Modified);
+            builder.AddEntries(ImmutableArray.Create(6), EntryState.Added);
+            var previousTable = builder.ToImmutableAndFree();
+
+            builder = previousTable.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(10, 11), EntryState.Added);
+            builder.TryUseCachedEntries(); // ((2, EntryState.Cached), (3, EntryState.Cached))
+            builder.AddEntries(ImmutableArray.Create(20, 21, 22), EntryState.Modified);
+            builder.RemoveEntries(); //((6, EntryState.Removed))); 
+            var newTable = builder.ToImmutableAndFree();
+
+            var expected = ImmutableArray.Create((10, EntryState.Added), (11, EntryState.Added), (2, EntryState.Cached), (3, EntryState.Cached), (20, EntryState.Modified), (21, EntryState.Modified), (22, EntryState.Modified), (6, EntryState.Removed));
+            AssertTableEntries(newTable, expected);
+        }
+
+        [Fact]
+        public void Node_Table_Entries_Are_Cached_Or_Dropped_When_Cached()
+        {
+            var builder = NodeStateTable<int>.Empty.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Added);
+            builder.AddEntries(ImmutableArray.Create(4, 5, 6), EntryState.Removed);
+            builder.AddEntries(ImmutableArray.Create(7, 8, 9), EntryState.Added);
+            var table = builder.ToImmutableAndFree();
+
+            var expected = ImmutableArray.Create((1, EntryState.Added), (2, EntryState.Added), (3, EntryState.Added), (4, EntryState.Removed), (5, EntryState.Removed), (6, EntryState.Removed), (7, EntryState.Added), (8, EntryState.Added), (9, EntryState.Added));
+            AssertTableEntries(table, expected);
+
+            var compactedTable = table.AsCached();
+            expected = ImmutableArray.Create((1, EntryState.Cached), (2, EntryState.Cached), (3, EntryState.Cached), (7, EntryState.Cached), (8, EntryState.Cached), (9, EntryState.Cached));
+            AssertTableEntries(compactedTable, expected);
+        }
+
+        [Fact]
+        public void Node_Table_AsCached_Occurs_Only_Once()
+        {
+            var builder = NodeStateTable<int>.Empty.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Added);
+            builder.AddEntries(ImmutableArray.Create(4, 5, 6), EntryState.Removed);
+            builder.AddEntries(ImmutableArray.Create(7, 8, 9), EntryState.Added);
+            var table = builder.ToImmutableAndFree();
+
+            var expected = ImmutableArray.Create((1, EntryState.Added), (2, EntryState.Added), (3, EntryState.Added), (4, EntryState.Removed), (5, EntryState.Removed), (6, EntryState.Removed), (7, EntryState.Added), (8, EntryState.Added), (9, EntryState.Added));
+            AssertTableEntries(table, expected);
+
+            var compactedTable = table.AsCached();
+            expected = ImmutableArray.Create((1, EntryState.Cached), (2, EntryState.Cached), (3, EntryState.Cached), (7, EntryState.Cached), (8, EntryState.Cached), (9, EntryState.Cached));
+            AssertTableEntries(compactedTable, expected);
+
+            // calling as cached a second time just returns the same instance
+            var compactedTable2 = compactedTable.AsCached();
+            Assert.Same(compactedTable, compactedTable2);
+        }
+
+        [Fact]
+        public void Node_Table_Single_Returns_First_Item()
+        {
+            var builder = NodeStateTable<int>.Empty.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(1), EntryState.Added);
+            var table = builder.ToImmutableAndFree();
+
+            Assert.Equal(1, table.Single());
+        }
+
+        [Fact]
+        public void Node_Table_Single_Returns_Second_Item_When_First_Is_Removed()
+        {
+            var builder = NodeStateTable<int>.Empty.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(1), EntryState.Added);
+            var table = builder.ToImmutableAndFree();
+
+            AssertTableEntries(table, new[] { (1, EntryState.Added) });
+
+            // remove the first item and replace it in the table
+            builder = table.ToBuilder();
+            builder.RemoveEntries();
+            builder.AddEntries(ImmutableArray.Create(2), EntryState.Added);
+            table = builder.ToImmutableAndFree();
+
+            AssertTableEntries(table, new[] { (1, EntryState.Removed), (2, EntryState.Added) });
+            Assert.Equal(2, table.Single());
+        }
+
+        [Fact]
+        public void Node_Builder_Handles_Modification_When_Both_Tables_Have_Empty_Entries()
+        {
+            var builder = NodeStateTable<int>.Empty.ToBuilder();
+            builder.AddEntries(ImmutableArray.Create(1, 2), EntryState.Added);
+            builder.AddEntries(ImmutableArray<int>.Empty, EntryState.Added);
+            builder.AddEntries(ImmutableArray.Create(3, 4), EntryState.Added);
+            var previousTable = builder.ToImmutableAndFree();
+
+            var expected = ImmutableArray.Create((1, EntryState.Added), (2, EntryState.Added), (3, EntryState.Added), (4, EntryState.Added));
+            AssertTableEntries(previousTable, expected);
+
+            builder = previousTable.ToBuilder();
+            Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 2), EqualityComparer<int>.Default)); // ((3, EntryState.Modified), (2, EntryState.Cached))
+            Assert.True(builder.TryModifyEntries(ImmutableArray<int>.Empty, EqualityComparer<int>.Default)); // nothing
+            Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 5), EqualityComparer<int>.Default)); // ((3, EntryState.Cached), (5, EntryState.Modified))
+            var newTable = builder.ToImmutableAndFree();
+
+            expected = ImmutableArray.Create((3, EntryState.Modified), (2, EntryState.Cached), (3, EntryState.Cached), (5, EntryState.Modified));
+            AssertTableEntries(newTable, expected);
+        }
+
+        [Fact]
+        public void Driver_Table_Calls_Into_Node_With_Self()
+        {
+            DriverStateTable.Builder? passedIn = null;
+            CallbackNode<int> callbackNode = new CallbackNode<int>((b, s) =>
+            {
+                passedIn = b;
+                return s;
+            });
+
+            DriverStateTable.Builder builder = GetBuilder(DriverStateTable.Empty);
+            builder.GetLatestStateTableForNode(callbackNode);
+
+            Assert.Same(builder, passedIn);
+        }
+
+        [Fact]
+        public void Driver_Table_Calls_Into_Node_With_EmptyState_FirstTime()
+        {
+            NodeStateTable<int>? passedIn = null;
+            CallbackNode<int> callbackNode = new CallbackNode<int>((b, s) =>
+            {
+                passedIn = s;
+                return s;
+            });
+
+            DriverStateTable.Builder builder = GetBuilder(DriverStateTable.Empty);
+            builder.GetLatestStateTableForNode(callbackNode);
+
+            Assert.Same(NodeStateTable<int>.Empty, passedIn);
+        }
+
+        [Fact]
+        public void Driver_Table_Calls_Into_Node_With_PreviousTable()
+        {
+            var nodeBuilder = NodeStateTable<int>.Empty.ToBuilder();
+            nodeBuilder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Cached);
+            var newTable = nodeBuilder.ToImmutableAndFree();
+
+            NodeStateTable<int>? passedIn = null;
+            CallbackNode<int> callbackNode = new CallbackNode<int>((b, s) =>
+            {
+                passedIn = s;
+                return newTable;
+            });
+
+            // empty first time
+            DriverStateTable.Builder builder = GetBuilder(DriverStateTable.Empty);
+            builder.GetLatestStateTableForNode(callbackNode);
+
+            Assert.Same(NodeStateTable<int>.Empty, passedIn);
+
+            // gives the returned table the second time around
+            DriverStateTable.Builder builder2 = GetBuilder(builder.ToImmutable());
+            builder2.GetLatestStateTableForNode(callbackNode);
+
+            Assert.NotNull(passedIn);
+            AssertTableEntries(passedIn!, new[] { (1, EntryState.Cached), (2, EntryState.Cached), (3, EntryState.Cached) });
+        }
+
+        [Fact]
+        public void Driver_Table_Compacts_State_Tables_When_Made_Immutable()
+        {
+            var nodeBuilder = NodeStateTable<int>.Empty.ToBuilder();
+            nodeBuilder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Added);
+            nodeBuilder.AddEntries(ImmutableArray.Create(4), EntryState.Removed);
+            nodeBuilder.AddEntries(ImmutableArray.Create(5, 6), EntryState.Modified);
+
+            var newTable = nodeBuilder.ToImmutableAndFree();
+
+            NodeStateTable<int>? passedIn = null;
+            CallbackNode<int> callbackNode = new CallbackNode<int>((b, s) =>
+            {
+                passedIn = s;
+                return newTable;
+            });
+
+            // empty first time
+            DriverStateTable.Builder builder = GetBuilder(DriverStateTable.Empty);
+            builder.GetLatestStateTableForNode(callbackNode);
+            Assert.Same(NodeStateTable<int>.Empty, passedIn);
+
+            // gives the returned table the second time around
+            DriverStateTable.Builder builder2 = GetBuilder(builder.ToImmutable());
+            builder2.GetLatestStateTableForNode(callbackNode);
+
+            // table returned from the first instance was compacted by the builder
+            Assert.NotNull(passedIn);
+            AssertTableEntries(passedIn!, new[] { (1, EntryState.Cached), (2, EntryState.Cached), (3, EntryState.Cached), (5, EntryState.Cached), (6, EntryState.Cached) });
+        }
+
+        [Fact]
+        public void Driver_Table_Builder_Doesnt_Build_Twice()
+        {
+            int callCount = 0;
+            CallbackNode<int> callbackNode = new CallbackNode<int>((b, s) =>
+            {
+                callCount++;
+                return s;
+            });
+
+            // multiple gets will only call it once
+            DriverStateTable.Builder builder = GetBuilder(DriverStateTable.Empty);
+            builder.GetLatestStateTableForNode(callbackNode);
+            builder.GetLatestStateTableForNode(callbackNode);
+            builder.GetLatestStateTableForNode(callbackNode);
+
+            Assert.Equal(1, callCount);
+
+            // second time around we'll call it once, but no more
+            DriverStateTable.Builder builder2 = GetBuilder(builder.ToImmutable());
+            builder2.GetLatestStateTableForNode(callbackNode);
+            builder2.GetLatestStateTableForNode(callbackNode);
+            builder2.GetLatestStateTableForNode(callbackNode);
+
+            Assert.Equal(2, callCount);
+        }
+
+        private void AssertTableEntries<T>(NodeStateTable<T> table, IList<(T item, EntryState state)> expected)
+        {
+            int index = 0;
+            foreach (var entry in table)
+            {
+                Assert.Equal(expected[index].item, entry.item);
+                Assert.Equal(expected[index].state, entry.state);
+                index++;
+            }
+        }
+
+        private DriverStateTable.Builder GetBuilder(DriverStateTable previous)
+        {
+            var options = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp10);
+            var c = CSharpCompilation.Create("empty");
+            var state = new GeneratorDriverState(options,
+                    CompilerAnalyzerConfigOptionsProvider.Empty,
+                    ImmutableArray<ISourceGenerator>.Empty,
+                    ImmutableArray<IIncrementalGenerator>.Empty,
+                    ImmutableArray<AdditionalText>.Empty,
+                    ImmutableArray<GeneratorState>.Empty,
+                    previous,
+                    enableIncremental: true);
+
+            return new DriverStateTable.Builder(c, state, ImmutableArray<ISyntaxInputNode>.Empty);
+        }
+
+        private class CallbackNode<T> : IIncrementalGeneratorNode<T>
+        {
+            private readonly Func<DriverStateTable.Builder, NodeStateTable<T>, NodeStateTable<T>> _callback;
+
+            public CallbackNode(Func<DriverStateTable.Builder, NodeStateTable<T>, NodeStateTable<T>> callback)
+            {
+                _callback = callback;
+            }
+
+            public NodeStateTable<T> UpdateStateTable(DriverStateTable.Builder graphState, NodeStateTable<T> previousTable, CancellationToken cancellationToken)
+            {
+                return _callback(graphState, previousTable);
+            }
+
+            public IIncrementalGeneratorNode<T> WithComparer(IEqualityComparer<T> comparer) => this;
+
+            public void RegisterOutput(IIncrementalGeneratorOutputNode output) { }
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/SyntaxAwareGeneratorTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/SyntaxAwareGeneratorTests.cs
index a518e2ab63efb..de26416353238 100644
--- a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/SyntaxAwareGeneratorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/SyntaxAwareGeneratorTests.cs
@@ -841,6 +841,950 @@ class C
             Assert.Null(syntaxRx);
         }
 
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source1, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    spc.AddSource(fieldName, "");
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            var results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Multiple_Filters()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class classC 
+{
+    string fieldA = null; 
+}
+";
+            var source2 = @"
+#pragma warning disable CS0414
+class classD 
+{
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(new[] { source1, source2 }, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    spc.AddSource(fieldName, "");
+                });
+
+                var source2 = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is ClassDeclarationSyntax fds, (c, _) => ((ClassDeclarationSyntax)c.Node).Identifier.ValueText);
+                context.RegisterSourceOutput(source2, (spc, className) =>
+                {
+                    spc.AddSource(className, "");
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            var results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("classC.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("classD.cs", results.GeneratedTrees[2].FilePath);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_Does_Not_Run_When_Not_Changed()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source1, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> fieldsCalledFor = new List<string>();
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    spc.AddSource(fieldName, "");
+                    fieldsCalledFor.Add(fieldName);
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            var results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.Equal("fieldA", fieldsCalledFor[0]);
+            Assert.Equal("fieldB", fieldsCalledFor[1]);
+            Assert.Equal("fieldC", fieldsCalledFor[2]);
+
+            // clear out the collected state and run again on the *same* compilation
+            fieldsCalledFor.Clear();
+            driver = driver.RunGenerators(compilation);
+            results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            // we produced the same source, but didn't call back at all
+            Assert.Empty(fieldsCalledFor);
+
+            // now change the compilation, but don't change the syntax trees
+            compilation = compilation.WithAssemblyName("newCompilation");
+            fieldsCalledFor.Clear();
+            driver = driver.RunGenerators(compilation);
+            results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.Empty(fieldsCalledFor);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_Added_Tree()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}";
+
+            var source2 = @"
+#pragma warning disable CS0414
+class D
+{
+    string fieldD = null; 
+    string fieldE = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source1, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> fieldsCalledFor = new List<string>();
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    spc.AddSource(fieldName, "");
+                    fieldsCalledFor.Add(fieldName);
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            var results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.Equal(3, fieldsCalledFor.Count);
+            Assert.Equal("fieldA", fieldsCalledFor[0]);
+            Assert.Equal("fieldB", fieldsCalledFor[1]);
+            Assert.Equal("fieldC", fieldsCalledFor[2]);
+
+
+            // add the second tree and re-run
+            fieldsCalledFor.Clear();
+            compilation = compilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(source2, parseOptions));
+            driver = driver.RunGenerators(compilation);
+
+            results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(5, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.EndsWith("fieldD.cs", results.GeneratedTrees[3].FilePath);
+            Assert.EndsWith("fieldE.cs", results.GeneratedTrees[4].FilePath);
+            Assert.Equal(2, fieldsCalledFor.Count);
+            Assert.Equal("fieldD", fieldsCalledFor[0]);
+            Assert.Equal("fieldE", fieldsCalledFor[1]);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_Removed_Tree()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}";
+
+            var source2 = @"
+#pragma warning disable CS0414
+class D
+{
+    string fieldD = null; 
+    string fieldE = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(new[] { source1, source2 }, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> fieldsCalledFor = new List<string>();
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    spc.AddSource(fieldName, "");
+                    fieldsCalledFor.Add(fieldName);
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            var results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(5, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.EndsWith("fieldD.cs", results.GeneratedTrees[3].FilePath);
+            Assert.EndsWith("fieldE.cs", results.GeneratedTrees[4].FilePath);
+            Assert.Equal(5, fieldsCalledFor.Count);
+            Assert.Equal("fieldA", fieldsCalledFor[0]);
+            Assert.Equal("fieldB", fieldsCalledFor[1]);
+            Assert.Equal("fieldC", fieldsCalledFor[2]);
+            Assert.Equal("fieldD", fieldsCalledFor[3]);
+            Assert.Equal("fieldE", fieldsCalledFor[4]);
+
+            // remove the second tree and re-run
+            fieldsCalledFor.Clear();
+            compilation = compilation.RemoveSyntaxTrees(compilation.SyntaxTrees.Last());
+            driver = driver.RunGenerators(compilation);
+
+            results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.Empty(fieldsCalledFor);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_Runs_Only_For_Changed_Trees()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+}";
+            var source2 = @"
+#pragma warning disable CS0414
+class D 
+{
+    string fieldB = null; 
+}";
+            var source3 = @"
+#pragma warning disable CS0414
+class E 
+{
+    string fieldC = null; 
+}";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(new[] { source1, source2, source3 }, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> fieldsCalledFor = new List<string>();
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    spc.AddSource(fieldName, "");
+                    fieldsCalledFor.Add(fieldName);
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            var results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.Equal("fieldA", fieldsCalledFor[0]);
+            Assert.Equal("fieldB", fieldsCalledFor[1]);
+            Assert.Equal("fieldC", fieldsCalledFor[2]);
+
+            // edit one of the syntax trees
+            var firstTree = compilation.SyntaxTrees.First();
+            var newTree = CSharpSyntaxTree.ParseText(@"
+#pragma warning disable CS0414
+class F 
+{
+    string fieldD = null; 
+}", parseOptions);
+            compilation = compilation.ReplaceSyntaxTree(firstTree, newTree);
+
+            // now re-run the drivers 
+            fieldsCalledFor.Clear();
+            driver = driver.RunGenerators(compilation);
+            results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+
+            // we produced the expected modified sources, but only called for the one different tree
+            Assert.EndsWith("fieldD.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.Single(fieldsCalledFor, "fieldD");
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_And_Changed_Tree_Order()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+}";
+            var source2 = @"
+#pragma warning disable CS0414
+class D 
+{
+    string fieldB = null; 
+}";
+            var source3 = @"
+#pragma warning disable CS0414
+class E 
+{
+    string fieldC = null; 
+}";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(new[] { source1, source2, source3 }, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> fieldsCalledFor = new List<string>();
+            List<string> syntaxFieldsCalledFor = new List<string>();
+
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) =>
+                {
+                    if (c is FieldDeclarationSyntax fds)
+                    {
+                        syntaxFieldsCalledFor.Add(fds.Declaration.Variables[0].Identifier.ValueText);
+                        return true;
+                    }
+                    return false;
+                },
+                (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    spc.AddSource(fieldName, "");
+                    fieldsCalledFor.Add(fieldName);
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            var results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.Equal("fieldA", fieldsCalledFor[0]);
+            Assert.Equal("fieldB", fieldsCalledFor[1]);
+            Assert.Equal("fieldC", fieldsCalledFor[2]);
+            Assert.Equal("fieldA", syntaxFieldsCalledFor[0]);
+            Assert.Equal("fieldB", syntaxFieldsCalledFor[1]);
+            Assert.Equal("fieldC", syntaxFieldsCalledFor[2]);
+
+            //swap the order of the first and last trees
+            var firstTree = compilation.SyntaxTrees.First();
+            var lastTree = compilation.SyntaxTrees.Last();
+            var dummyTree = CSharpSyntaxTree.ParseText("", parseOptions);
+
+            compilation = compilation.ReplaceSyntaxTree(firstTree, dummyTree)
+                                     .ReplaceSyntaxTree(lastTree, firstTree)
+                                     .ReplaceSyntaxTree(dummyTree, lastTree);
+
+            // now re-run the drivers and confirm we didn't actually run
+            fieldsCalledFor.Clear();
+            syntaxFieldsCalledFor.Clear();
+            driver = driver.RunGenerators(compilation);
+            results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.Empty(fieldsCalledFor);
+            Assert.Empty(syntaxFieldsCalledFor);
+
+
+            // swap a tree for a tree with the same contents, but a new reference
+            var newLastTree = CSharpSyntaxTree.ParseText(lastTree.ToString(), parseOptions);
+
+            compilation = compilation.ReplaceSyntaxTree(firstTree, dummyTree)
+                                     .ReplaceSyntaxTree(lastTree, firstTree)
+                                     .ReplaceSyntaxTree(dummyTree, newLastTree);
+
+            // now re-run the drivers and confirm we only ran for the 'new' syntax tree
+            // but then stopped when we got the same value out
+            fieldsCalledFor.Clear();
+            syntaxFieldsCalledFor.Clear();
+            driver = driver.RunGenerators(compilation);
+            results = driver.GetRunResult();
+            Assert.Empty(results.Diagnostics);
+            Assert.Equal(3, results.GeneratedTrees.Length);
+            Assert.EndsWith("fieldA.cs", results.GeneratedTrees[0].FilePath);
+            Assert.EndsWith("fieldB.cs", results.GeneratedTrees[1].FilePath);
+            Assert.EndsWith("fieldC.cs", results.GeneratedTrees[2].FilePath);
+            Assert.Empty(fieldsCalledFor);
+            Assert.Single(syntaxFieldsCalledFor);
+            Assert.Equal("fieldC", syntaxFieldsCalledFor[0]);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_Can_Have_Comparer()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source1, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> calledFor = new List<string>();
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                source = source.WithComparer(new LambdaComparer<string>((a, b) => false));
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    calledFor.Add(fieldName);
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, calledFor);
+
+            // when we run it again, we get the same fields called for
+            // even though they were cached, because of our comparer
+            calledFor.Clear();
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, calledFor);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_And_Comparer_Doesnt_Do_Duplicate_Work()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source1, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> syntaxCalledFor = new List<string>();
+
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) =>
+                {
+                    syntaxCalledFor.Add(((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                    return ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText;
+                });
+                source = source.WithComparer(new LambdaComparer<string>((a, b) => false));
+                source = source.WithComparer(new LambdaComparer<string>((a, b) => false));
+                source = source.WithComparer(new LambdaComparer<string>((a, b) => false));
+                source = source.WithComparer(new LambdaComparer<string>((a, b) => false));
+                context.RegisterSourceOutput(source, (spc, fieldName) => { });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            // verify we only call the syntax transform once, even though we created multiple nodes via the withComparer
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, syntaxCalledFor);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_And_Comparer_Can_Feed_Two_Outputs()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source1, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> syntaxCalledFor = new List<string>();
+            List<string> noCompareCalledFor = new List<string>();
+            List<string> compareCalledFor = new List<string>();
+
+
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) =>
+                {
+                    syntaxCalledFor.Add(((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                    return ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText;
+                });
+
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    noCompareCalledFor.Add(fieldName);
+                });
+
+                var comparerSource = source.WithComparer(new LambdaComparer<string>((a, b) => false));
+                context.RegisterSourceOutput(comparerSource, (spc, fieldName) =>
+                {
+                    compareCalledFor.Add(fieldName);
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            // verify we ran the syntax transform twice, one for each output, even though we duplicated them
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC", "fieldA", "fieldB", "fieldC" }, syntaxCalledFor);
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, noCompareCalledFor);
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, compareCalledFor);
+
+            // now, when we re-run, both transforms will run, but only the comparare output will re-run
+            syntaxCalledFor.Clear();
+            noCompareCalledFor.Clear();
+            compareCalledFor.Clear();
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC", "fieldA", "fieldB", "fieldC" }, syntaxCalledFor);
+            Assert.Empty(noCompareCalledFor);
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, compareCalledFor);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_Can_Feed_Two_Outputs()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source1, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> syntaxCalledFor = new List<string>();
+            List<string> output1CalledFor = new List<string>();
+            List<string> output2CalledFor = new List<string>();
+
+
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) =>
+                {
+                    syntaxCalledFor.Add(((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                    return ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText;
+                });
+
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    output1CalledFor.Add("Output1_" + fieldName);
+                });
+
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                    output2CalledFor.Add("Output2_" + fieldName);
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            // verify we ran the syntax transform once, but fed both outputs
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC", }, syntaxCalledFor);
+            Assert.Equal(new[] { "Output1_fieldA", "Output1_fieldB", "Output1_fieldC" }, output1CalledFor);
+            Assert.Equal(new[] { "Output2_fieldA", "Output2_fieldB", "Output2_fieldC" }, output2CalledFor);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_Isnt_Duplicated_By_Combines()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source1, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> syntaxCalledFor = new List<string>();
+            List<string> outputCalledFor = new List<string>();
+
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) =>
+                {
+                    syntaxCalledFor.Add(((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                    return ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText;
+                });
+
+                var source2 = source.Combine(context.AdditionalTextsProvider.Collect())
+                                    .Combine(context.AnalyzerConfigOptionsProvider)
+                                    .Combine(context.ParseOptionsProvider);
+
+                context.RegisterSourceOutput(source2, (spc, output) =>
+                {
+                    outputCalledFor.Add(output.Left.Left.Left);
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            // verify we only ran the syntax transform once, even though we called through a join
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC", }, syntaxCalledFor);
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, outputCalledFor);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_With_Syntax_Filter_And_Comparer_Survive_Combines()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source1, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            List<string> syntaxCalledFor = new List<string>();
+            List<string> outputCalledFor = new List<string>();
+
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) =>
+                {
+                    syntaxCalledFor.Add(((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                    return ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText;
+                });
+
+                var comparerSource = source.WithComparer(new LambdaComparer<string>((a, b) => false));
+
+                // now join the two sources together
+                var joinedSource = source.Combine(comparerSource.Collect());
+                context.RegisterSourceOutput(joinedSource, (spc, fieldName) =>
+                {
+                    outputCalledFor.Add(fieldName.Left);
+                });
+
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            // verify we ran the syntax transform twice, one for each input node, but only called into the output once
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC", "fieldA", "fieldB", "fieldC" }, syntaxCalledFor);
+            Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, outputCalledFor);
+        }
+
+        [Fact]
+        public void IncrementalGenerator_Throws_In_Syntax_Filter()
+        {
+            var source = @"
+class C 
+{
+    int Property { get; set; }
+
+    void Function()
+    {
+        var x = 5;
+        x += 4;
+    }
+}
+";
+            var parseOptions = TestOptions.Regular.WithLanguageVersion(LanguageVersion.Preview);
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var exception = new Exception("Test Exception");
+            var testGenerator = new PipelineCallbackGenerator(ctx =>
+            {
+                ctx.RegisterSourceOutput(ctx.SyntaxProvider.CreateSyntaxProvider((s, _) => { if (s is AssignmentExpressionSyntax) throw exception; return true; }, (c, _) => c.Node), (spc, s) => { });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var outputDiagnostics);
+            var results = driver.GetRunResult();
+
+            Assert.Empty(results.GeneratedTrees);
+            Assert.Single(results.Diagnostics);
+
+            Assert.Single(results.Results[0].Diagnostics);
+            Assert.NotNull(results.Results[0].Exception);
+            Assert.Equal("Test Exception", results.Results[0].Exception?.Message);
+
+            outputDiagnostics.Verify(
+                Diagnostic("CS" + (int)ErrorCode.WRN_GeneratorFailedDuringGeneration).WithArguments("PipelineCallbackGenerator", "Exception", "Test Exception").WithLocation(1, 1)
+                );
+        }
+
+        [Fact]
+        public void IncrementalGenerator_Throws_In_Syntax_Transform()
+        {
+            var source = @"
+class C 
+{
+    int Property { get; set; }
+
+    void Function()
+    {
+        var x = 5;
+        x += 4;
+    }
+}
+";
+            var parseOptions = TestOptions.Regular.WithLanguageVersion(LanguageVersion.Preview);
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var exception = new Exception("Test Exception");
+            var testGenerator = new PipelineCallbackGenerator(ctx =>
+            {
+                ctx.RegisterSourceOutput(ctx.SyntaxProvider.CreateSyntaxProvider<object>((s, _) => s is AssignmentExpressionSyntax, (c, _) => throw exception), (spc, s) => { });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var outputDiagnostics);
+            var results = driver.GetRunResult();
+
+            Assert.Empty(results.GeneratedTrees);
+            Assert.Single(results.Diagnostics);
+
+            Assert.Single(results.Results[0].Diagnostics);
+            Assert.NotNull(results.Results[0].Exception);
+            Assert.Equal("Test Exception", results.Results[0].Exception?.Message);
+
+            outputDiagnostics.Verify(
+                Diagnostic("CS" + (int)ErrorCode.WRN_GeneratorFailedDuringGeneration).WithArguments("PipelineCallbackGenerator", "Exception", "Test Exception").WithLocation(1, 1)
+                );
+        }
+
+        [Fact]
+        public void IncrementalGenerator_Throws_In_Syntax_Transform_Doesnt_Stop_Other_Generators()
+        {
+            var source = @"
+class C 
+{
+    int Property { get; set; }
+
+    void Function()
+    {
+        var x = 5;
+        x += 4;
+    }
+}
+";
+            var parseOptions = TestOptions.Regular.WithLanguageVersion(LanguageVersion.Preview);
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            var exception = new Exception("Test Exception");
+            var testGenerator = new PipelineCallbackGenerator(ctx =>
+            {
+                ctx.RegisterSourceOutput(ctx.SyntaxProvider.CreateSyntaxProvider<object>((s, _) => s is AssignmentExpressionSyntax, (c, _) => throw exception), (spc, s) => { });
+            });
+
+            var testGenerator2 = new PipelineCallbackGenerator2(ctx =>
+            {
+                ctx.RegisterSourceOutput(ctx.CompilationProvider, (spc, s) => spc.AddSource("test", ""));
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator), new IncrementalGeneratorWrapper(testGenerator2) }, parseOptions: parseOptions);
+            driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var outputDiagnostics);
+            var results = driver.GetRunResult();
+
+            Assert.Single(results.GeneratedTrees);
+            Assert.Single(results.Diagnostics);
+
+            Assert.Single(results.Results[0].Diagnostics);
+            Assert.NotNull(results.Results[0].Exception);
+            Assert.Equal("Test Exception", results.Results[0].Exception?.Message);
+
+            Assert.Single(results.Results[1].GeneratedSources);
+            Assert.Null(results.Results[1].Exception);
+
+            outputDiagnostics.Verify(
+                Diagnostic("CS" + (int)ErrorCode.WRN_GeneratorFailedDuringGeneration).WithArguments("PipelineCallbackGenerator", "Exception", "Test Exception").WithLocation(1, 1)
+                );
+        }
+
+        [Fact]
+        public void Incremental_Generators_Can_Be_Cancelled_During_Syntax()
+        {
+            var source = @"
+class C 
+{
+    int Property { get; set; }
+
+    void Function()
+    {
+        var x = 5;
+        x += 4;
+    }
+}
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            CancellationTokenSource cts = new CancellationTokenSource();
+            int filterCalled = 0;
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ctx) =>
+            {
+                var step1 = ctx.SyntaxProvider.CreateSyntaxProvider((c, ct) => { filterCalled++; if (c is AssignmentExpressionSyntax) cts.Cancel(); return true; }, (a, _) => a);
+                ctx.RegisterSourceOutput(step1, (spc, c) => spc.AddSource("step1", ""));
+            }));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            Assert.Throws<OperationCanceledException>(() => driver = driver.RunGenerators(compilation, cancellationToken: cts.Token));
+            Assert.Equal(19, filterCalled);
+        }
+
+        [Fact]
+        public void Incremental_Generators_Can_Be_Cancelled_During_Syntax_And_Stop_Other_SyntaxVisits()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            Assert.Single(compilation.SyntaxTrees);
+
+            CancellationTokenSource cts = new CancellationTokenSource();
+            bool generatorCancelled = false;
+
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator((ctx) =>
+            {
+                var step1 = ctx.SyntaxProvider.CreateSyntaxProvider((c, ct) => { generatorCancelled = true; cts.Cancel(); return true; }, (a, _) => a);
+                ctx.RegisterSourceOutput(step1, (spc, c) => spc.AddSource("step1", ""));
+
+                var step2 = ctx.SyntaxProvider.CreateSyntaxProvider((c, ct) => { return true; }, (a, _) => a);
+                ctx.RegisterSourceOutput(step2, (spc, c) => spc.AddSource("step2", ""));
+            }));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            Assert.Throws<OperationCanceledException>(() => driver = driver.RunGenerators(compilation, cancellationToken: cts.Token));
+            Assert.True(generatorCancelled);
+        }
+
         private class TestReceiverBase<T>
         {
             private readonly Action<T>? _callback;
diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
index 188a65c7fe99f..00d944065650d 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
@@ -2060,14 +2060,14 @@ public void ReferenceManagerReuse_WithReferences()
         [Fact]
         public void ReferenceManagerReuse_WithSyntaxTrees()
         {
-            var ta = Parse("class C { }");
+            var ta = Parse("class C { }", options: TestOptions.Regular10);
 
             var tb = Parse(@"
 class C { }", options: TestOptions.Script);
 
             var tc = Parse(@"
 #r ""bar""  // error: #r in regular code
-class D { }");
+class D { }", options: TestOptions.Regular10);
 
             var tr = Parse(@"
 #r ""goo""
diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/UsedAssembliesTests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/UsedAssembliesTests.cs
index 3e291c27d2dac..896a66f247db4 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/UsedAssembliesTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/UsedAssembliesTests.cs
@@ -186,7 +186,7 @@ void assertUsedAssemblyReferences(Compilation comp, MetadataReference[] expected
 ");
             builder.Append(afterUsings);
 
-            var parseOptions = ((CSharpParseOptions)tree.Options).WithLanguageVersion(LanguageVersion.Preview);
+            var parseOptions = ((CSharpParseOptions)tree.Options).WithLanguageVersion(LanguageVersion.CSharp10);
             yield return (comp.ReplaceSyntaxTree(tree, CSharpTestBase.Parse(builder.ToString(), tree.FilePath, parseOptions)), before, after);
 
             // With global usings in a separate unit
diff --git a/src/Compilers/CSharp/Test/Symbol/DocumentationComments/CrefTests.cs b/src/Compilers/CSharp/Test/Symbol/DocumentationComments/CrefTests.cs
index 19bf6cfcede32..8b4c6f0b30c14 100644
--- a/src/Compilers/CSharp/Test/Symbol/DocumentationComments/CrefTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/DocumentationComments/CrefTests.cs
@@ -6769,7 +6769,7 @@ public void OnRecordStruct(string terminator)
 /// </summary>
 record struct CacheContext(string RelativePathBase)" + terminator;
 
-            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.Preview), targetFramework: TargetFramework.NetCoreApp);
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp10), targetFramework: TargetFramework.NetCoreApp);
             comp.VerifyDiagnostics(
                 // (6,25): warning CS1574: XML comment has cref attribute 'InvalidCref' that could not be resolved
                 // /// See also <see cref="InvalidCref"/>.
@@ -6814,7 +6814,7 @@ public void OnRecordStruct_WithoutPrimaryCtor(string terminator)
 /// </summary>
 record struct CacheContext" + terminator;
 
-            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.Preview), targetFramework: TargetFramework.NetCoreApp);
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp10), targetFramework: TargetFramework.NetCoreApp);
             comp.VerifyDiagnostics(
                 // (5,25): warning CS1574: XML comment has cref attribute 'InvalidCref' that could not be resolved
                 // /// See also <see cref="InvalidCref"/>.
diff --git a/src/Compilers/CSharp/Test/Symbol/SymbolDisplay/SymbolDisplayTests.cs b/src/Compilers/CSharp/Test/Symbol/SymbolDisplay/SymbolDisplayTests.cs
index 2fb52eb889c1c..7f142995debb0 100644
--- a/src/Compilers/CSharp/Test/Symbol/SymbolDisplay/SymbolDisplayTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/SymbolDisplay/SymbolDisplayTests.cs
@@ -7688,7 +7688,7 @@ record struct Person(string First, string Last);
                 text,
                 findSymbol,
                 format,
-                TestOptions.Regular.WithLanguageVersion(LanguageVersion.Preview),
+                TestOptions.Regular10,
                 "record struct Person",
                 SymbolDisplayPartKind.Keyword,
                 SymbolDisplayPartKind.Space,
@@ -7711,7 +7711,7 @@ public void ReadOnlyRecordStructDeclaration()
                 text,
                 findSymbol,
                 format,
-                TestOptions.Regular.WithLanguageVersion(LanguageVersion.Preview),
+                TestOptions.Regular10,
                 "readonly record struct Person",
                 SymbolDisplayPartKind.Keyword,
                 SymbolDisplayPartKind.Space,
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/AccessorOverriddenOrHiddenMembersTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/AccessorOverriddenOrHiddenMembersTests.cs
index 0d1ec556a82a9..4a00528652828 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/AccessorOverriddenOrHiddenMembersTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/AccessorOverriddenOrHiddenMembersTests.cs
@@ -352,7 +352,7 @@ public class C : I
 
             Assert.NotEqual(ilGetter.Name, csharpGetter.Name); //name not copied
 
-            var bridge = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).Single();
+            var bridge = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single();
             Assert.Same(csharpGetter, bridge.ImplementingMethod);
             Assert.Same(ilGetter, bridge.ExplicitInterfaceImplementations.Single());
 
@@ -384,7 +384,7 @@ public class C : I
             var csharpGetter = @class.GetProperty("I.P").GetMethod;
 
             Assert.Equal("I.getter", csharpGetter.Name);
-            Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).Length); //not needed
+            Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length); //not needed
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/DefaultInterfaceImplementationTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/DefaultInterfaceImplementationTests.cs
index cdcf4580a744f..9e1bc151e8bfb 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/DefaultInterfaceImplementationTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/DefaultInterfaceImplementationTests.cs
@@ -3257,21 +3257,18 @@ class Test1 : I1
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
 
             compilation1.VerifyDiagnostics(
-                // (4,22): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                // (4,16): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     static int P1 => 1;
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "1").WithArguments("default interface implementation", "8.0").WithLocation(4, 22),
-                // (5,21): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "P1").WithArguments("default interface implementation", "8.0").WithLocation(4, 16),
+                // (5,16): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     static int P3 { get => 3; }
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(5, 21),
-                // (6,21): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "P3").WithArguments("default interface implementation", "8.0").WithLocation(5, 16),
+                // (6,16): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     static int P5 { set => System.Console.WriteLine(5); }
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "set").WithArguments("default interface implementation", "8.0").WithLocation(6, 21),
-                // (7,21): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "P5").WithArguments("default interface implementation", "8.0").WithLocation(6, 16),
+                // (7,16): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     static int P7 { get { return 7;} set {} }
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(7, 21),
-                // (7,38): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     static int P7 { get { return 7;} set {} }
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "set").WithArguments("default interface implementation", "8.0").WithLocation(7, 38)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "P7").WithArguments("default interface implementation", "8.0").WithLocation(7, 16)
                 );
 
             var derived = compilation1.SourceModule.GlobalNamespace.GetTypeMember("Test1");
@@ -5833,12 +5830,9 @@ class Test1 : I1
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
 
             compilation1.VerifyDiagnostics(
-                // (6,9): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //         add {} 
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "add").WithArguments("default interface implementation", "8.0").WithLocation(6, 9),
-                // (7,9): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //         remove {} 
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "remove").WithArguments("default interface implementation", "8.0").WithLocation(7, 9)
+                // (4,32): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     static event System.Action E7 
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "E7").WithArguments("default interface implementation", "8.0").WithLocation(4, 32)
                 );
 
             var derived = compilation1.GlobalNamespace.GetTypeMember("Test1");
@@ -7008,19 +7002,19 @@ class Test2 : I1
 {}
 ";
             var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
 
             compilation1.VerifyDiagnostics(
-                // (10,24): error CS0238: 'I1.M3()' cannot be sealed because it is not an override
+                // (10,24): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     sealed static void M3() 
-                Diagnostic(ErrorCode.ERR_SealedNonOverride, "M3").WithArguments("I1.M3()").WithLocation(10, 24),
-                // (6,25): error CS0112: A static member 'I1.M2()' cannot be marked as override, virtual, or abstract
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M3").WithArguments("sealed", "9.0", "preview").WithLocation(10, 24),
+                // (6,25): error CS0112: A static member cannot be marked as 'virtual'
                 //     virtual static void M2() 
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M2").WithArguments("I1.M2()").WithLocation(6, 25),
-                // (4,26): error CS0112: A static member 'I1.M1()' cannot be marked as override, virtual, or abstract
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M2").WithArguments("virtual").WithLocation(6, 25),
+                // (4,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     abstract static void M1(); 
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M1").WithArguments("I1.M1()").WithLocation(4, 26),
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M1").WithArguments("abstract", "9.0", "preview").WithLocation(4, 26),
                 // (21,13): error CS0539: 'Test1.M4()' in explicit interface declaration is not found among members of the interface that can be implemented
                 //     void I1.M4() {}
                 Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M4").WithArguments("Test1.M4()").WithLocation(21, 13),
@@ -7032,7 +7026,13 @@ class Test2 : I1
                 Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M2").WithArguments("Test1.M2()").WithLocation(23, 13),
                 // (24,13): error CS0539: 'Test1.M3()' in explicit interface declaration is not found among members of the interface that can be implemented
                 //     void I1.M3() {}
-                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M3").WithArguments("Test1.M3()").WithLocation(24, 13)
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M3").WithArguments("Test1.M3()").WithLocation(24, 13),
+                // (19,15): error CS0535: 'Test1' does not implement interface member 'I1.M1()'
+                // class Test1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.M1()").WithLocation(19, 15),
+                // (27,15): error CS0535: 'Test2' does not implement interface member 'I1.M1()'
+                // class Test2 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test2", "I1.M1()").WithLocation(27, 15)
                 );
 
             var test1 = compilation1.GetTypeByMetadataName("Test1");
@@ -7053,8 +7053,8 @@ class Test2 : I1
             var m2 = i1.GetMember<MethodSymbol>("M2");
 
             Assert.False(m2.IsAbstract);
-            Assert.True(m2.IsVirtual);
-            Assert.True(m2.IsMetadataVirtual());
+            Assert.False(m2.IsVirtual);
+            Assert.False(m2.IsMetadataVirtual());
             Assert.False(m2.IsSealed);
             Assert.True(m2.IsStatic);
             Assert.False(m2.IsExtern);
@@ -7068,7 +7068,7 @@ class Test2 : I1
             Assert.False(m3.IsAbstract);
             Assert.False(m3.IsVirtual);
             Assert.False(m3.IsMetadataVirtual());
-            Assert.True(m3.IsSealed);
+            Assert.False(m3.IsSealed);
             Assert.True(m3.IsStatic);
             Assert.False(m3.IsExtern);
             Assert.False(m3.IsAsync);
@@ -7247,17 +7247,25 @@ public void M1()
 }
 ";
             var compilation1 = CreateCompilation(source1 + source2, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation1.VerifyDiagnostics(
-                // (9,15): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (9,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(9, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(9, 15)
                 );
 
             ValidateMethodModifiersImplicit_10(compilation1.SourceModule, Accessibility.Internal);
 
+            compilation1 = CreateCompilation(source1 + source2, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular10,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, Accessibility.Internal)).VerifyDiagnostics();
+
+            ValidateMethodModifiersImplicit_10(compilation1.SourceModule, Accessibility.Internal);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
@@ -7266,29 +7274,6 @@ public void M1()
 
             ValidateMethodModifiers_10(compilation2.GetTypeByMetadataName("I1").GetMember<MethodSymbol>("M1"), Accessibility.Internal);
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation3.VerifyDiagnostics(
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
-                // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 15)
-                );
-
-            ValidateMethodModifiersImplicit_10(compilation3.SourceModule, Accessibility.Internal);
-
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation4.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation4.VerifyDiagnostics(
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
-                // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 15)
-                );
-
-            ValidateMethodModifiersImplicit_10(compilation4.SourceModule, Accessibility.Internal);
 
             var source3 =
 @"
@@ -7297,29 +7282,40 @@ class Test2 : I1
 }
 ";
 
-            var compilation5 = CreateCompilation(source3, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation5.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation5.VerifyDiagnostics(
-                // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.M1()'
-                // class Test2 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test2", "I1.M1()").WithLocation(2, 15)
-                );
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                compilation3.VerifyDiagnostics(
+                    // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                    // class Test1 : I1
+                    Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 15)
+                    );
 
-            ValidateI1M1NotImplemented(compilation5, "Test2");
+                ValidateMethodModifiersImplicit_10(compilation3.SourceModule, Accessibility.Internal);
 
-            var compilation6 = CreateCompilation(source3, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
+                compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular10,
                                                  targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation6.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation6.VerifyDiagnostics(
-                // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.M1()'
-                // class Test2 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test2", "I1.M1()").WithLocation(2, 15)
-                );
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, Accessibility.Internal)).VerifyDiagnostics();
+
+                ValidateMethodModifiersImplicit_10(compilation3.SourceModule, Accessibility.Internal);
 
-            ValidateI1M1NotImplemented(compilation6, "Test2");
+                var compilation5 = CreateCompilation(source3, new[] { reference }, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.Regular,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation5.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                compilation5.VerifyDiagnostics(
+                    // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.M1()'
+                    // class Test2 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test2", "I1.M1()").WithLocation(2, 15)
+                    );
+
+                ValidateI1M1NotImplemented(compilation5, "Test2");
+            }
         }
 
         private static void ValidateI1M1NotImplemented(CSharpCompilation compilation, string className)
@@ -7361,11 +7357,7 @@ private static void ValidateMethodModifiers_10(ModuleSymbol m, bool implementedB
             Assert.NotNull(implementation);
             Assert.Same(implementation, test1.FindImplementationForInterfaceMember(m1));
 
-            var i2 = test1.InterfacesNoUseSiteDiagnostics().Where(i => i.Name == "I2").SingleOrDefault();
-            Assert.Equal(implementation.IsVirtual || implementation.IsAbstract || isExplicit ||
-                         (!implementedByBase && (object)i2 != null &&
-                             (object)implementation == test1.FindImplementationForInterfaceMember(i2.GetMember<MethodSymbol>("M1"))),
-                         implementation.IsMetadataVirtual());
+            Assert.True(implementation.IsMetadataVirtual());
         }
 
         private static void ValidateMethodModifiers_10(MethodSymbol m1, Accessibility accessibility)
@@ -7408,27 +7400,34 @@ static void Main()
 
     public virtual void M1() 
     {
-        System.Console.WriteLine(""M1"");
+        System.Console.WriteLine(""Test1.M1"");
     }
 }
 ";
 
             ValidateMethodModifiers_10_02(source1, source2, Accessibility.Internal,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
         private void ValidateMethodModifiers_10_02(string source1, string source2,
                                                   Accessibility accessibility,
-                                                  params DiagnosticDescription[] expected)
+                                                  params DiagnosticDescription[] expectedIn9)
         {
             var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation1.VerifyDiagnostics(expected);
+            compilation1.VerifyDiagnostics(expectedIn9);
+
+            ValidateMethodModifiersImplicit_10(compilation1.SourceModule, accessibility);
+
+            compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "Test1.M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, accessibility)).VerifyDiagnostics();
 
             ValidateMethodModifiersImplicit_10(compilation1.SourceModule, accessibility);
 
@@ -7440,21 +7439,23 @@ private void ValidateMethodModifiers_10_02(string source1, string source2,
 
             ValidateMethodModifiers_10(compilation2.GetTypeByMetadataName("I1").GetMember<MethodSymbol>("M1"), accessibility);
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation3.VerifyDiagnostics(expected);
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                compilation3.VerifyDiagnostics(expectedIn9);
 
-            ValidateMethodModifiersImplicit_10(compilation3.SourceModule, accessibility);
+                ValidateMethodModifiersImplicit_10(compilation3.SourceModule, accessibility);
 
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation4.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation4.VerifyDiagnostics(expected);
+                compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "Test1.M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, accessibility)).VerifyDiagnostics();
 
-            ValidateMethodModifiersImplicit_10(compilation4.SourceModule, accessibility);
+                ValidateMethodModifiersImplicit_10(compilation3.SourceModule, accessibility);
+            }
         }
 
         [Fact]
@@ -7565,9 +7566,9 @@ public void M1()
 }
 ";
             ValidateMethodModifiers_10_02(source1, source2, Accessibility.Internal,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -7611,9 +7612,9 @@ public virtual void M1()
 }
 ";
             ValidateMethodModifiers_10_02(source1, source2, Accessibility.Internal,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -7657,14 +7658,14 @@ class Test3 : Test1
 {
     public override void M1() 
     {
-        System.Console.WriteLine(""Test3.M1"");
+        System.Console.WriteLine(""Test1.M1"");
     }
 }
 ";
             ValidateMethodModifiers_10_02(source1, source2, Accessibility.Internal,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -7713,9 +7714,9 @@ public interface I2
 }
 ";
             ValidateMethodModifiers_10_02(source1, source2, Accessibility.Internal,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 22)
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // class Test1 : Test2, I1, I2
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -7823,9 +7824,9 @@ public virtual int M1()
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation1.VerifyDiagnostics(
-                // (9,15): error CS0535: 'Test1' does not implement interface member 'I1.M1()'
+                // (9,15): error CS0738: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implement 'I1.M1()' because it does not have the matching return type of 'void'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.M1()").WithLocation(9, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "void").WithLocation(9, 15)
                 );
 
             ValidateI1M1NotImplemented(compilation1, "Test1");
@@ -7843,9 +7844,9 @@ public virtual int M1()
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation3.VerifyDiagnostics(
-                // (2,15): error CS0535: 'Test1' does not implement interface member 'I1.M1()'
+                // (2,15): error CS0738: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implement 'I1.M1()' because it does not have the matching return type of 'void'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.M1()").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "void").WithLocation(2, 15)
                 );
 
             ValidateI1M1NotImplemented(compilation3, "Test1");
@@ -7855,9 +7856,9 @@ public virtual int M1()
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation4.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation4.VerifyDiagnostics(
-                // (2,15): error CS0535: 'Test1' does not implement interface member 'I1.M1()'
+                // (2,15): error CS0738: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implement 'I1.M1()' because it does not have the matching return type of 'void'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.M1()").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "void").WithLocation(2, 15)
                 );
 
             ValidateI1M1NotImplemented(compilation4, "Test1");
@@ -7871,6 +7872,8 @@ public void MethodModifiers_10_10()
 public interface I1
 {
     internal abstract void M1(); 
+
+    void M2() {M1();}
 }
 ";
 
@@ -7886,47 +7889,63 @@ public void M1()
 
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.M2();
+    }
 }
 ";
-            var compilation1 = CreateCompilation(source1 + source2, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            var compilation1 = CreateCompilation(source1 + source2, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
             compilation1.VerifyDiagnostics(
-                // (7,15): error CS8504: 'Test2' does not implement interface member 'I1.M1()'. 'Test2.M1()' cannot implicitly implement a non-public member.
+                // (9,15): error CS8704: 'Test2' does not implement interface member 'I1.M1()'. 'Test2.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.M1()", "Test2.M1()").WithLocation(7, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.M1()", "Test2.M1()", "9.0", "10.0").WithLocation(9, 15)
                 );
 
             ValidateMethodModifiersImplicitInTest2_10(compilation1.SourceModule, Accessibility.Internal);
 
+            compilation1 = CreateCompilation(source1 + source2, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicitInTest2_10(m, Accessibility.Internal)).VerifyDiagnostics();
+
+            ValidateMethodModifiersImplicitInTest2_10(compilation1.SourceModule, Accessibility.Internal);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
             compilation2.VerifyDiagnostics();
 
             ValidateMethodModifiers_10(compilation2.GetTypeByMetadataName("I1").GetMember<MethodSymbol>("M1"), Accessibility.Internal);
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
 
-            compilation3.VerifyDiagnostics(
-                // (2,15): error CS8504: 'Test2' does not implement interface member 'I1.M1()'. 'Test2.M1()' cannot implicitly implement a non-public member.
-                // class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.M1()", "Test2.M1()")
-                );
+                compilation3.VerifyDiagnostics(
+                    // (2,15): error CS8704: 'Test2' does not implement interface member 'I1.M1()'. 'Test2.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                    // class Test2 : I1
+                    Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.M1()", "Test2.M1()", "9.0", "10.0").WithLocation(2, 15)
+                    );
 
-            ValidateMethodModifiersImplicitInTest2_10(compilation3.SourceModule, Accessibility.Internal);
+                ValidateMethodModifiersImplicitInTest2_10(compilation3.SourceModule, Accessibility.Internal);
 
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+                compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
-            compilation4.VerifyDiagnostics(
-                // (2,15): error CS8504: 'Test2' does not implement interface member 'I1.M1()'. 'Test2.M1()' cannot implicitly implement a non-public member.
-                // class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.M1()", "Test2.M1()")
-                );
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicitInTest2_10(m, Accessibility.Internal)).VerifyDiagnostics();
 
-            ValidateMethodModifiersImplicitInTest2_10(compilation4.SourceModule, Accessibility.Internal);
+                ValidateMethodModifiersImplicitInTest2_10(compilation3.SourceModule, Accessibility.Internal);
+            }
         }
 
         [Fact]
@@ -7937,6 +7956,8 @@ public void MethodModifiers_10_11()
 public interface I1
 {
     internal abstract void M1(); 
+
+    void M2() {M1();}
 }
 
 public class Test2 : I1
@@ -7952,30 +7973,35 @@ public void M1()
 @"
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.M2();
+    }
 }
 ";
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
                                                  parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp,
                                                  assemblyName: "MethodModifiers_10_11");
 
-            compilation2.VerifyDiagnostics(
-                // (7,22): error CS8504: 'Test2' does not implement interface member 'I1.M1()'. 'Test2.M1()' cannot implicitly implement a non-public member.
-                // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.M1()", "Test2.M1()").WithLocation(7, 22)
-                );
+            compilation2.VerifyDiagnostics();
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
-            compilation3.VerifyDiagnostics();
+            CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicitInTest2_10(m, Accessibility.Internal)).VerifyDiagnostics();
 
             ValidateMethodModifiersImplicitInTest2_10(compilation3.SourceModule, Accessibility.Internal);
 
-            var compilation3Ref = compilation3.EmitToImageReference();
-            var compilation4 = CreateCompilation("", new[] { compilation2.ToMetadataReference(), compilation3Ref }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicitInTest2_10(m, Accessibility.Internal)).VerifyDiagnostics();
 
-            ValidateMethodModifiersImplicitInTest2_10(compilation4.GetReferencedAssemblySymbol(compilation3Ref).Modules[0], Accessibility.Internal);
+            ValidateMethodModifiersImplicitInTest2_10(compilation3.SourceModule, Accessibility.Internal);
         }
 
         [Fact]
@@ -8588,7 +8614,7 @@ void I1.M5() {}
 }
 ";
             var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation1.VerifyDiagnostics(
@@ -8610,12 +8636,15 @@ void I1.M5() {}
                 // (5,27): error CS0621: 'I1.M2()': virtual or abstract members cannot be private
                 //     abstract private void M2() {} 
                 Diagnostic(ErrorCode.ERR_VirtualPrivate, "M2").WithArguments("I1.M2()").WithLocation(5, 27),
-                // (6,26): error CS0112: A static member 'I1.M3()' cannot be marked as override, virtual, or abstract
+                // (6,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     abstract static void M3() {} 
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M3").WithArguments("I1.M3()").WithLocation(6, 26),
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M3").WithArguments("abstract", "9.0", "preview").WithLocation(6, 26),
                 // (11,15): error CS0535: 'Test1' does not implement interface member 'I1.M2()'
                 // class Test1 : I1
                 Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.M2()").WithLocation(11, 15),
+                // (11,15): error CS0535: 'Test1' does not implement interface member 'I1.M3()'
+                // class Test1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.M3()").WithLocation(11, 15),
                 // (11,15): error CS0535: 'Test1' does not implement interface member 'I1.M1()'
                 // class Test1 : I1
                 Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.M1()").WithLocation(11, 15),
@@ -8630,7 +8659,10 @@ void I1.M5() {}
                 Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M4").WithArguments("Test2.M4()").WithLocation(20, 13),
                 // (21,13): error CS0539: 'Test2.M5()' in explicit interface declaration is not found among members of the interface that can be implemented
                 //     void I1.M5() {}
-                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M5").WithArguments("Test2.M5()").WithLocation(21, 13)
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M5").WithArguments("Test2.M5()").WithLocation(21, 13),
+                // (15,15): error CS0535: 'Test2' does not implement interface member 'I1.M3()'
+                // class Test2 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test2", "I1.M3()").WithLocation(15, 15)
                 );
 
             var test1 = compilation1.GetTypeByMetadataName("Test1");
@@ -9732,10 +9764,11 @@ public void MethodModifiers_34()
 public interface I1
 {
     protected abstract void M1(); 
+    public void M2() => M1();
 }
 ";
 
-            var source2 =
+            var source21 =
 @"
 class Test1 : I1
 {
@@ -9751,15 +9784,15 @@ public void M1()
     }
 }
 ";
-            var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
+            var compilation1 = CreateCompilation(source21 + source1, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
 
             var expected = new DiagnosticDescription[] {
-                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 15),
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 15),
                 // (7,11): error CS1540: Cannot access protected member 'I1.M1()' via a qualifier of type 'I1'; the qualifier must be of type 'Test1' (or derived from it)
                 //         x.M1();
                 Diagnostic(ErrorCode.ERR_BadProtectedAccess, "M1").WithArguments("I1.M1()", "I1", "Test1").WithLocation(7, 11)
@@ -9769,6 +9802,32 @@ public void M1()
 
             ValidateMethodModifiersImplicit_10(compilation1.SourceModule, Accessibility.Protected);
 
+            var source22 =
+@"
+class Test1 : I1
+{
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.M2();
+    }
+
+    public void M1() 
+    {
+        System.Console.WriteLine(""M1"");
+    }
+}
+";
+            compilation1 = CreateCompilation(source22 + source1, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+            Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+
+
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, Accessibility.Protected)).VerifyDiagnostics();
+
+            ValidateMethodModifiersImplicit_10(compilation1.SourceModule, Accessibility.Protected);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
@@ -9787,14 +9846,22 @@ class Test2 : I1
 
             foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
             {
-                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
-                                                     parseOptions: TestOptions.Regular,
+                var compilation3 = CreateCompilation(source21, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
                                                      targetFramework: TargetFramework.NetCoreApp);
                 Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
                 compilation3.VerifyDiagnostics(expected);
 
                 ValidateMethodModifiersImplicit_10(compilation3.SourceModule, Accessibility.Protected);
 
+                compilation3 = CreateCompilation(source22, new[] { reference }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, Accessibility.Protected)).VerifyDiagnostics();
+                ValidateMethodModifiersImplicit_10(compilation3.SourceModule, Accessibility.Protected);
+
                 var compilation5 = CreateCompilation(source3, new[] { reference }, options: TestOptions.DebugDll,
                                                      parseOptions: TestOptions.Regular,
                                                      targetFramework: TargetFramework.NetCoreApp);
@@ -9817,10 +9884,11 @@ public void MethodModifiers_35()
 public interface I1
 {
     protected internal abstract void M1(); 
+    public void M2() => M1();
 }
 ";
 
-            var source2 =
+            var source21 =
 @"
 class Test1 : I1
 {
@@ -9836,19 +9904,46 @@ public virtual void M1()
     }
 }
 ";
-            var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
+
+            var source22 =
+@"
+class Test1 : I1
+{
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.M2();
+    }
+
+    public virtual void M1() 
+    {
+        System.Console.WriteLine(""M1"");
+    }
+}
+";
+
+            var compilation1 = CreateCompilation(source21 + source1, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
 
             compilation1.VerifyDiagnostics(
-                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 15)
                 );
 
             ValidateMethodModifiersImplicit_10(compilation1.SourceModule, Accessibility.ProtectedOrInternal);
 
+            compilation1 = CreateCompilation(source21 + source1, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+            Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, Accessibility.ProtectedOrInternal)).VerifyDiagnostics();
+
+            ValidateMethodModifiersImplicit_10(compilation1.SourceModule, Accessibility.ProtectedOrInternal);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
@@ -9867,14 +9962,14 @@ class Test2 : I1
 
             foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
             {
-                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
-                                                     parseOptions: TestOptions.Regular,
+                var compilation3 = CreateCompilation(source21, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
                                                      targetFramework: TargetFramework.NetCoreApp);
                 Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
                 compilation3.VerifyDiagnostics(
-                    // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                    // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                     // class Test1 : I1
-                    Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 15),
+                    Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 15),
                     // (7,11): error CS1540: Cannot access protected member 'I1.M1()' via a qualifier of type 'I1'; the qualifier must be of type 'Test1' (or derived from it)
                     //         x.M1();
                     Diagnostic(ErrorCode.ERR_BadProtectedAccess, "M1").WithArguments("I1.M1()", "I1", "Test1").WithLocation(7, 11)
@@ -9882,6 +9977,13 @@ class Test2 : I1
 
                 ValidateMethodModifiersImplicit_10(compilation3.SourceModule, Accessibility.ProtectedOrInternal);
 
+                compilation3 = CreateCompilation(source22, new[] { reference }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, Accessibility.ProtectedOrInternal)).VerifyDiagnostics();
+                ValidateMethodModifiersImplicit_10(compilation3.SourceModule, Accessibility.ProtectedOrInternal);
+
                 var compilation5 = CreateCompilation(source3, new[] { reference }, options: TestOptions.DebugDll,
                                                      parseOptions: TestOptions.Regular,
                                                      targetFramework: TargetFramework.NetCoreApp);
@@ -9904,10 +10006,11 @@ public void MethodModifiers_36()
 public interface I1
 {
     private protected abstract void M1(); 
+    public void M2() => M1();
 }
 ";
 
-            var source2 =
+            var source21 =
 @"
 class Test1 : I1
 {
@@ -9923,15 +10026,32 @@ public void M1()
     }
 }
 ";
-            var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
+
+            var source22 =
+@"
+class Test1 : I1
+{
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.M2();
+    }
+
+    public void M1() 
+    {
+        System.Console.WriteLine(""M1"");
+    }
+}
+";
+            var compilation1 = CreateCompilation(source21 + source1, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
 
             compilation1.VerifyDiagnostics(
-                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 15),
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 15),
                 // (7,11): error CS1540: Cannot access protected member 'I1.M1()' via a qualifier of type 'I1'; the qualifier must be of type 'Test1' (or derived from it)
                 //         x.M1();
                 Diagnostic(ErrorCode.ERR_BadProtectedAccess, "M1").WithArguments("I1.M1()", "I1", "Test1").WithLocation(7, 11)
@@ -9939,6 +10059,15 @@ public void M1()
 
             ValidateMethodModifiersImplicit_10(compilation1.SourceModule, Accessibility.ProtectedAndInternal);
 
+            compilation1 = CreateCompilation(source22 + source1, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+            Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, Accessibility.ProtectedAndInternal)).VerifyDiagnostics();
+
+            ValidateMethodModifiersImplicit_10(compilation1.SourceModule, Accessibility.ProtectedAndInternal);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
@@ -9957,14 +10086,14 @@ class Test2 : I1
 
             foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
             {
-                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
-                                                     parseOptions: TestOptions.Regular,
+                var compilation3 = CreateCompilation(source21, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
                                                      targetFramework: TargetFramework.NetCoreApp);
                 Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
                 compilation3.VerifyDiagnostics(
-                    // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                    // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                     // class Test1 : I1
-                    Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 15),
+                    Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 15),
                     // (7,11): error CS0122: 'I1.M1()' is inaccessible due to its protection level
                     //         x.M1();
                     Diagnostic(ErrorCode.ERR_BadAccess, "M1").WithArguments("I1.M1()").WithLocation(7, 11)
@@ -9972,6 +10101,14 @@ class Test2 : I1
 
                 ValidateMethodModifiersImplicit_10(compilation3.SourceModule, Accessibility.ProtectedAndInternal);
 
+                compilation3 = CreateCompilation(source22, new[] { reference }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "M1", verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateMethodModifiersImplicit_10(m, Accessibility.ProtectedAndInternal)).VerifyDiagnostics();
+                ValidateMethodModifiersImplicit_10(compilation3.SourceModule, Accessibility.ProtectedAndInternal);
+
                 var compilation5 = CreateCompilation(source3, new[] { reference }, options: TestOptions.DebugDll,
                                                      parseOptions: TestOptions.Regular,
                                                      targetFramework: TargetFramework.NetCoreApp);
@@ -10179,6 +10316,7 @@ public void MethodModifiers_40()
 public interface I1
 {
     protected abstract void M1(); 
+    public void M2() => M1();
 }
 
 public class Test2 : I1
@@ -10195,17 +10333,20 @@ class Test1 : Test2, I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public void M1() 
     {
+        System.Console.WriteLine(""Test1.M1"");
     }
 }
 ";
             ValidateMethodModifiers_10_02(source1, source2, Accessibility.Protected,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -10217,6 +10358,7 @@ public void MethodModifiers_41()
 public interface I1
 {
     protected internal abstract void M1(); 
+    public void M2() => M1();
 }
 
 public class Test2 : I1
@@ -10233,17 +10375,20 @@ class Test1 : Test2, I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public void M1() 
     {
+        System.Console.WriteLine(""Test1.M1"");
     }
 }
 ";
             ValidateMethodModifiers_10_02(source1, source2, Accessibility.ProtectedOrInternal,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -10255,6 +10400,7 @@ public void MethodModifiers_42()
 public interface I1
 {
     private protected abstract void M1(); 
+    public void M2() => M1();
 }
 
 public class Test2 : I1
@@ -10271,17 +10417,20 @@ class Test1 : Test2, I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public virtual void M1() 
     {
+        System.Console.WriteLine(""Test1.M1"");
     }
 }
 ";
             ValidateMethodModifiers_10_02(source1, source2, Accessibility.ProtectedAndInternal,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.M1()", "Test1.M1()", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -11293,9 +11442,6 @@ public interface I1
                 // (9,16): error CS8503: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     static int P06 {get;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P06").WithArguments("static", "7.3", "8.0").WithLocation(9, 16),
-                // (9,21): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     static int P06 {get;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(9, 21),
                 // (10,17): error CS8503: The modifier 'virtual' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     virtual int P07 {set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P07").WithArguments("virtual", "7.3", "8.0").WithLocation(10, 17),
@@ -12063,19 +12209,22 @@ class Test2 : I1
 {}
 ";
             var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
 
             compilation1.VerifyDiagnostics(
-                // (4,25): error CS0112: A static member 'I1.P1' cannot be marked as override, virtual, or abstract
+                // (4,25): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     abstract static int P1 {get;} 
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P1").WithArguments("I1.P1").WithLocation(4, 25),
-                // (6,24): error CS0112: A static member 'I1.P2' cannot be marked as override, virtual, or abstract
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P1").WithArguments("abstract", "9.0", "preview").WithLocation(4, 25),
+                // (6,24): error CS0112: A static member cannot be marked as 'virtual'
                 //     virtual static int P2 {set {}} 
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P2").WithArguments("I1.P2").WithLocation(6, 24),
-                // (8,23): error CS0238: 'I1.P3' cannot be sealed because it is not an override
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P2").WithArguments("virtual").WithLocation(6, 24),
+                // (8,23): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     sealed static int P3 => 0; 
-                Diagnostic(ErrorCode.ERR_SealedNonOverride, "P3").WithArguments("I1.P3").WithLocation(8, 23),
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P3").WithArguments("sealed", "9.0", "preview").WithLocation(8, 23),
+                // (13,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
+                // class Test1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.P1").WithLocation(13, 15),
                 // (15,12): error CS0539: 'Test1.P1' in explicit interface declaration is not found among members of the interface that can be implemented
                 //     int I1.P1 => 0;
                 Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "P1").WithArguments("Test1.P1").WithLocation(15, 12),
@@ -12087,7 +12236,10 @@ class Test2 : I1
                 Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "P3").WithArguments("Test1.P3").WithLocation(17, 12),
                 // (18,12): error CS0539: 'Test1.P4' in explicit interface declaration is not found among members of the interface that can be implemented
                 //     int I1.P4 {set {}}
-                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "P4").WithArguments("Test1.P4").WithLocation(18, 12)
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "P4").WithArguments("Test1.P4").WithLocation(18, 12),
+                // (21,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
+                // class Test2 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test2", "I1.P1").WithLocation(21, 15)
                 );
 
             var test1 = compilation1.GetTypeByMetadataName("Test1");
@@ -12119,7 +12271,7 @@ class Test2 : I1
             var p2set = p2.SetMethod;
 
             Assert.False(p2.IsAbstract);
-            Assert.True(p2.IsVirtual);
+            Assert.False(p2.IsVirtual);
             Assert.False(p2.IsSealed);
             Assert.True(p2.IsStatic);
             Assert.False(p2.IsExtern);
@@ -12128,8 +12280,8 @@ class Test2 : I1
             Assert.Null(test1.FindImplementationForInterfaceMember(p2));
 
             Assert.False(p2set.IsAbstract);
-            Assert.True(p2set.IsVirtual);
-            Assert.True(p2set.IsMetadataVirtual());
+            Assert.False(p2set.IsVirtual);
+            Assert.False(p2set.IsMetadataVirtual());
             Assert.False(p2set.IsSealed);
             Assert.True(p2set.IsStatic);
             Assert.False(p2set.IsExtern);
@@ -12143,7 +12295,7 @@ class Test2 : I1
 
             Assert.False(p3.IsAbstract);
             Assert.False(p3.IsVirtual);
-            Assert.True(p3.IsSealed);
+            Assert.False(p3.IsSealed);
             Assert.True(p3.IsStatic);
             Assert.False(p3.IsExtern);
             Assert.False(p3.IsOverride);
@@ -12153,7 +12305,7 @@ class Test2 : I1
             Assert.False(p3get.IsAbstract);
             Assert.False(p3get.IsVirtual);
             Assert.False(p3get.IsMetadataVirtual());
-            Assert.True(p3get.IsSealed);
+            Assert.False(p3get.IsSealed);
             Assert.True(p3get.IsStatic);
             Assert.False(p3get.IsExtern);
             Assert.False(p3get.IsAsync);
@@ -12574,12 +12726,12 @@ public int P1
 
             ValidatePropertyModifiers_11_01(source1, source2, Accessibility.Internal,
                 new DiagnosticDescription[] {
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 15)
                 },
                 // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
                 // class Test2 : I1
@@ -12592,13 +12744,25 @@ private void ValidatePropertyModifiers_11_01(string source1, string source2, Acc
                                                   params DiagnosticDescription[] expected2)
         {
             var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation1.VerifyDiagnostics(expected1);
 
             ValidatePropertyModifiers_11(compilation1.SourceModule, accessibility);
 
+            compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+            Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                             verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidatePropertyModifiers_11(m, accessibility)).VerifyDiagnostics();
+
+            ValidatePropertyModifiers_11(compilation1.SourceModule, accessibility);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
@@ -12616,22 +12780,6 @@ private void ValidatePropertyModifiers_11_01(string source1, string source2, Acc
                 ValidatePropertyAccessorModifiers_11(p1set, accessibility);
             }
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation3.VerifyDiagnostics(expected1);
-
-            ValidatePropertyModifiers_11(compilation3.SourceModule, accessibility);
-
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation4.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation4.VerifyDiagnostics(expected1);
-
-            ValidatePropertyModifiers_11(compilation4.SourceModule, accessibility);
-
             var source3 =
 @"
 class Test2 : I1
@@ -12639,21 +12787,35 @@ class Test2 : I1
 }
 ";
 
-            var compilation5 = CreateCompilation(source3, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation5.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation5.VerifyDiagnostics(expected2);
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                compilation3.VerifyDiagnostics(expected1);
 
-            ValidatePropertyNotImplemented_11(compilation5, "Test2");
+                ValidatePropertyModifiers_11(compilation3.SourceModule, accessibility);
 
-            var compilation6 = CreateCompilation(source3, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugDll,
+                compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation6.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation6.VerifyDiagnostics(expected2);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                                 verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidatePropertyModifiers_11(m, accessibility)).VerifyDiagnostics();
+
+                ValidatePropertyModifiers_11(compilation3.SourceModule, accessibility);
 
-            ValidatePropertyNotImplemented_11(compilation6, "Test2");
+                var compilation5 = CreateCompilation(source3, new[] { reference }, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.Regular,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation5.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                compilation5.VerifyDiagnostics(expected2);
+
+                ValidatePropertyNotImplemented_11(compilation5, "Test2");
+            }
         }
 
         private static void ValidatePropertyModifiers_11(ModuleSymbol m, Accessibility accessibility)
@@ -12748,12 +12910,12 @@ public virtual int P1
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -12761,34 +12923,51 @@ private void ValidatePropertyModifiers_11_02(string source1, string source2,
                                                   params DiagnosticDescription[] expected)
         {
             var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation1.VerifyDiagnostics(expected);
 
             ValidatePropertyImplementation_11(compilation1.SourceModule);
 
+            compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+            Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                             verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidatePropertyImplementation_11(m)).VerifyDiagnostics();
+
+            ValidatePropertyImplementation_11(compilation1.SourceModule);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation2.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation2.VerifyDiagnostics();
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation3.VerifyDiagnostics(expected);
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                compilation3.VerifyDiagnostics(expected);
 
-            ValidatePropertyImplementation_11(compilation3.SourceModule);
+                ValidatePropertyImplementation_11(compilation3.SourceModule);
 
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugExe,
+                compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation4.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation4.VerifyDiagnostics(expected);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                                 verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidatePropertyImplementation_11(m)).VerifyDiagnostics();
 
-            ValidatePropertyImplementation_11(compilation4.SourceModule);
+                ValidatePropertyImplementation_11(compilation3.SourceModule);
+            }
         }
 
         private static void ValidatePropertyImplementation_11(ModuleSymbol m)
@@ -12816,10 +12995,8 @@ private static void ValidatePropertyImplementation_11(ModuleSymbol m, bool imple
             Assert.Same(test1P1.SetMethod, test1.FindImplementationForInterfaceMember(p1set));
 
             var i2 = test1.InterfacesNoUseSiteDiagnostics().Where(i => i.Name == "I2").SingleOrDefault();
-            bool isMetadataVirtual = test1P1.IsVirtual || test1P1.IsAbstract || test1P1.IsExplicitInterfaceImplementation ||
-                (!implementedByBase && (object)i2 != null && (object)test1P1 == test1.FindImplementationForInterfaceMember(GetSingleProperty(i2)));
-            Assert.Equal(isMetadataVirtual, test1P1.GetMethod.IsMetadataVirtual());
-            Assert.Equal(isMetadataVirtual, test1P1.SetMethod.IsMetadataVirtual());
+            Assert.True(test1P1.GetMethod.IsMetadataVirtual());
+            Assert.True(test1P1.SetMethod.IsMetadataVirtual());
         }
 
         [Fact]
@@ -12953,24 +13130,24 @@ public int P1
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -13020,24 +13197,24 @@ public virtual int P1
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -13092,24 +13269,24 @@ public override int P1
     {
         get
         {
-            System.Console.WriteLine(""Test3.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test3.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 22)
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // class Test1 : Test2, I1, I2
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // class Test1 : Test2, I1, I2
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -13159,12 +13336,12 @@ public int P1
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
@@ -13176,12 +13353,12 @@ public interface I2
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 22)
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // class Test1 : Test2, I1, I2
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // class Test1 : Test2, I1, I2
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -13321,9 +13498,9 @@ public virtual long P1
 ";
 
             ValidatePropertyModifiers_11_09(source1, source2,
-                // (2,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
+                // (2,15): error CS0738: 'Test1' does not implement interface member 'I1.P1'. 'Test1.P1' cannot implement 'I1.P1' because it does not have the matching return type of 'int'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.P1").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.P1", "Test1.P1", "int").WithLocation(2, 15)
                 );
         }
 
@@ -13365,6 +13542,11 @@ public void PropertyModifiers_11_10()
 public interface I1
 {
     internal abstract int P1 {get; set;} 
+
+    sealed void Test()
+    {
+        P1 = P1;
+    }
 }
 ";
 
@@ -13376,23 +13558,32 @@ public int P1
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_10(source1, source2,
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.set'. 'Test2.P1.set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.set'. 'Test2.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.set", "Test2.P1.set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.get'. 'Test2.P1.get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.set", "Test2.P1.set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.get'. 'Test2.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.get", "Test2.P1.get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.get", "Test2.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -13400,30 +13591,51 @@ private void ValidatePropertyModifiers_11_10(string source1, string source2,
                                                      params DiagnosticDescription[] expected)
         {
             var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
             compilation1.VerifyDiagnostics(expected);
 
             ValidatePropertyImplementationByBase_11(compilation1.SourceModule);
 
+            compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                             verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidatePropertyImplementationByBase_11(m)).VerifyDiagnostics();
+
+            ValidatePropertyImplementationByBase_11(compilation1.SourceModule);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
             compilation2.VerifyDiagnostics();
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
 
-            compilation3.VerifyDiagnostics(expected);
+                compilation3.VerifyDiagnostics(expected);
 
-            ValidatePropertyImplementationByBase_11(compilation3.SourceModule);
+                ValidatePropertyImplementationByBase_11(compilation3.SourceModule);
 
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+                compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
-            compilation4.VerifyDiagnostics(expected);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                                 verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidatePropertyImplementationByBase_11(m)).VerifyDiagnostics();
 
-            ValidatePropertyImplementationByBase_11(compilation4.SourceModule);
+                ValidatePropertyImplementationByBase_11(compilation3.SourceModule);
+            }
         }
 
         [Fact]
@@ -13434,6 +13646,11 @@ public void PropertyModifiers_11_11()
 public interface I1
 {
     internal abstract int P1 {get; set;} 
+
+    sealed void Test()
+    {
+        P1 = P1;
+    }
 }
 public class Test2 : I1
 {
@@ -13441,9 +13658,13 @@ public int P1
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
@@ -13452,16 +13673,21 @@ public int P1
 @"
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_11(source1, source2,
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.set'. 'Test2.P1.set' cannot implicitly implement a non-public member.
+                // (11,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.get'. 'Test2.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.set", "Test2.P1.set").WithLocation(6, 22),
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.get'. 'Test2.P1.get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.get", "Test2.P1.get", "9.0", "10.0").WithLocation(11, 22),
+                // (11,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.set'. 'Test2.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.get", "Test2.P1.get").WithLocation(6, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.set", "Test2.P1.set", "9.0", "10.0").WithLocation(11, 22)
                 );
         }
 
@@ -13469,23 +13695,29 @@ private void ValidatePropertyModifiers_11_11(string source1, string source2,
                                                      params DiagnosticDescription[] expected)
         {
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
                                                  assemblyName: "PropertyModifiers_11_11");
 
             compilation2.VerifyDiagnostics(expected);
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp,
+                                             assemblyName: "PropertyModifiers_11_11");
 
-            compilation3.VerifyDiagnostics();
+            compilation2.VerifyDiagnostics();
 
-            ValidatePropertyImplementationByBase_11(compilation3.SourceModule);
+            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
-            var compilation3Ref = compilation3.EmitToImageReference();
-            var compilation4 = CreateCompilation("", new[] { compilation2.ToMetadataReference(), compilation3Ref }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                             verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidatePropertyImplementationByBase_11(m)).VerifyDiagnostics();
 
-            ValidatePropertyImplementationByBase_11(compilation4.GetReferencedAssemblySymbol(compilation3Ref).Modules[0]);
+            ValidatePropertyImplementationByBase_11(compilation3.SourceModule);
         }
 
         [Fact]
@@ -14702,19 +14934,19 @@ class Test2 : I1, I2, I3, I4, I5
             ValidatePropertyModifiers_18(source1,
                 // (4,22): error CS0500: 'I1.P1.get' cannot declare a body because it is marked abstract
                 //     abstract int P1 {get => 0; set => throw null;} 
-                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.P1.get"),
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.P1.get").WithLocation(4, 22),
                 // (4,32): error CS0500: 'I1.P1.set' cannot declare a body because it is marked abstract
                 //     abstract int P1 {get => 0; set => throw null;} 
-                Diagnostic(ErrorCode.ERR_AbstractHasBody, "set").WithArguments("I1.P1.set"),
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "set").WithArguments("I1.P1.set").WithLocation(4, 32),
                 // (8,26): error CS0621: 'I2.P2': virtual or abstract members cannot be private
                 //     abstract private int P2 => 0; 
                 Diagnostic(ErrorCode.ERR_VirtualPrivate, "P2").WithArguments("I2.P2").WithLocation(8, 26),
                 // (8,32): error CS0500: 'I2.P2.get' cannot declare a body because it is marked abstract
                 //     abstract private int P2 => 0; 
                 Diagnostic(ErrorCode.ERR_AbstractHasBody, "0").WithArguments("I2.P2.get").WithLocation(8, 32),
-                // (16,25): error CS0112: A static member 'I4.P4' cannot be marked as override, virtual, or abstract
+                // (16,25): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     abstract static int P4 { get {throw null;} set {throw null;}}
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P4").WithArguments("I4.P4").WithLocation(16, 25),
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P4").WithArguments("abstract", "9.0", "preview").WithLocation(16, 25),
                 // (16,30): error CS0500: 'I4.P4.get' cannot declare a body because it is marked abstract
                 //     abstract static int P4 { get {throw null;} set {throw null;}}
                 Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I4.P4.get").WithLocation(16, 30),
@@ -14753,14 +14985,20 @@ class Test2 : I1, I2, I3, I4, I5
                 Diagnostic(ErrorCode.WRN_ExternMethodNoImplementation, "get").WithArguments("I3.P3.get").WithLocation(12, 27),
                 // (12,32): warning CS0626: Method, operator, or accessor 'I3.P3.set' is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation.
                 //     static extern int P3 {get; set;} 
-                Diagnostic(ErrorCode.WRN_ExternMethodNoImplementation, "set").WithArguments("I3.P3.set").WithLocation(12, 32)
+                Diagnostic(ErrorCode.WRN_ExternMethodNoImplementation, "set").WithArguments("I3.P3.set").WithLocation(12, 32),
+                // (23,27): error CS0535: 'Test1' does not implement interface member 'I4.P4'
+                // class Test1 : I1, I2, I3, I4, I5
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I4").WithArguments("Test1", "I4.P4").WithLocation(23, 27),
+                // (27,27): error CS0535: 'Test2' does not implement interface member 'I4.P4'
+                // class Test2 : I1, I2, I3, I4, I5
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I4").WithArguments("Test2", "I4.P4").WithLocation(27, 27)
                 );
         }
 
         private void ValidatePropertyModifiers_18(string source1, params DiagnosticDescription[] expected)
         {
             var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation1.VerifyDiagnostics(expected);
@@ -15912,6 +16150,8 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public int P1 
@@ -15929,22 +16169,33 @@ public int P1
 }
 ";
             ValidatePropertyModifiers_23(source1, source2, Accessibility.Internal, Accessibility.Public,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
         private void ValidatePropertyModifiers_23(string source1, string source2, Accessibility getAccess, Accessibility setAccess, params DiagnosticDescription[] expected)
         {
             var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All),
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation1.VerifyDiagnostics(expected);
 
             Validate1(compilation1.SourceModule);
 
+            compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All),
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+            Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                             verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => Validate1(m)).VerifyDiagnostics();
+
+            Validate1(compilation1.SourceModule);
+
             void Validate1(ModuleSymbol m)
             {
                 var test1 = m.GlobalNamespace.GetTypeMember("Test1");
@@ -15961,23 +16212,29 @@ void Validate1(ModuleSymbol m)
 
             ValidateProperty23(GetSingleProperty(compilation2, "I1"), true, getAccess, setAccess);
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() },
-                                                 options: TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All),
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation3.VerifyDiagnostics(expected);
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference },
+                                                     options: TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All),
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                compilation3.VerifyDiagnostics(expected);
 
-            Validate1(compilation3.SourceModule);
+                Validate1(compilation3.SourceModule);
 
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() },
+                compilation3 = CreateCompilation(source2, new[] { reference },
                                                  options: TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All),
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation4.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation4.VerifyDiagnostics(expected);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                                 verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => Validate1(m)).VerifyDiagnostics();
 
-            Validate1(compilation4.SourceModule);
+                Validate1(compilation3.SourceModule);
+            }
         }
 
         [Fact]
@@ -16021,9 +16278,9 @@ public virtual int P1
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -16120,21 +16377,21 @@ public int P1
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -16184,21 +16441,21 @@ public virtual int P1
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -16253,21 +16510,21 @@ public override int P1
     {
         get
         {
-            System.Console.WriteLine(""Test3.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test3.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -16317,12 +16574,12 @@ public int P1
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
@@ -16334,9 +16591,9 @@ public interface I2
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 22)
+                    // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                    // class Test1 : Test2, I1, I2
+                    Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -16441,9 +16698,9 @@ public virtual long P1
 ";
 
             ValidatePropertyModifiers_11_09(source1, source2,
-                // (2,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
+                // (2,15): error CS0738: 'Test1' does not implement interface member 'I1.P1'. 'Test1.P1' cannot implement 'I1.P1' because it does not have the matching return type of 'int'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.P1").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.P1", "Test1.P1", "int").WithLocation(2, 15)
                 );
         }
 
@@ -16455,6 +16712,11 @@ public void PropertyModifiers_23_10()
 public interface I1
 {
     abstract int P1 {internal get; set;} 
+
+    sealed void Test()
+    {
+        P1 = P1;
+    }
 }
 ";
 
@@ -16466,20 +16728,29 @@ public int P1
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_10(source1, source2,
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.get'. 'Test2.P1.get' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.get'. 'Test2.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.get", "Test2.P1.get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.get", "Test2.P1.get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -16491,6 +16762,11 @@ public void PropertyModifiers_23_11()
 public interface I1
 {
     abstract int P1 {internal get; set;} 
+
+    sealed void Test()
+    {
+        P1 = P1;
+    }
 }
 public class Test2 : I1
 {
@@ -16498,9 +16774,13 @@ public int P1
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
@@ -16509,13 +16789,18 @@ public int P1
 @"
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_11(source1, source2,
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.get'. 'Test2.P1.get' cannot implicitly implement a non-public member.
+                // (11,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.get'. 'Test2.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.get", "Test2.P1.get").WithLocation(6, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.get", "Test2.P1.get", "9.0", "10.0").WithLocation(11, 22)
                 );
         }
 
@@ -16541,6 +16826,8 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public int P1 
@@ -16558,9 +16845,9 @@ public int P1
 }
 ";
             ValidatePropertyModifiers_23(source1, source2, Accessibility.Public, Accessibility.Internal,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -16605,9 +16892,9 @@ public virtual int P1
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -16704,21 +16991,21 @@ public int P1
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -16768,21 +17055,21 @@ public virtual int P1
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -16837,21 +17124,21 @@ public override int P1
     {
         get
         {
-            System.Console.WriteLine(""Test3.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test3.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -16901,12 +17188,12 @@ public int P1
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
@@ -16918,9 +17205,9 @@ public interface I2
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1, I2
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -17025,9 +17312,9 @@ public virtual long P1
 ";
 
             ValidatePropertyModifiers_11_09(source1, source2,
-                // (2,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
+                // (2,15): error CS0738: 'Test1' does not implement interface member 'I1.P1'. 'Test1.P1' cannot implement 'I1.P1' because it does not have the matching return type of 'int'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.P1").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.P1", "Test1.P1", "int").WithLocation(2, 15)
                 );
         }
 
@@ -17039,6 +17326,11 @@ public void PropertyModifiers_23_60()
 public interface I1
 {
     abstract int P1 {get; internal set;} 
+
+    sealed void Test()
+    {
+        P1 = P1;
+    }
 }
 ";
 
@@ -17050,20 +17342,29 @@ public int P1
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_10(source1, source2,
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.set'. 'Test2.P1.set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.set'. 'Test2.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.set", "Test2.P1.set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.set", "Test2.P1.set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -17075,6 +17376,11 @@ public void PropertyModifiers_23_61()
 public interface I1
 {
     abstract int P1 {get; internal set;} 
+
+    sealed void Test()
+    {
+        P1 = P1;
+    }
 }
 public class Test2 : I1
 {
@@ -17082,9 +17388,13 @@ public int P1
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
@@ -17093,13 +17403,18 @@ public int P1
 @"
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_11(source1, source2,
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.set'. 'Test2.P1.set' cannot implicitly implement a non-public member.
+                // (11,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.set'. 'Test2.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.set", "Test2.P1.set").WithLocation(6, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.set", "Test2.P1.set", "9.0", "10.0").WithLocation(11, 22)
                 );
         }
 
@@ -17866,6 +18181,11 @@ public void PropertyModifiers_29()
 public interface I1
 {
     protected abstract int P1 {get; set;} 
+
+    sealed void Test()
+    {
+        P1 = P1;
+    }
 }
 ";
 
@@ -17875,24 +18195,33 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.Test();
     }
 
     public int P1 
     {
-        get => 0;
-        set {}
+        get
+        {
+            System.Console.WriteLine(""get_P1"");
+            return 0;
+        }
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_01(source1, source2, Accessibility.Protected,
                 new DiagnosticDescription[] {
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 15)
                 },
                 // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
                 // class Test2 : I1
@@ -17908,6 +18237,11 @@ public void PropertyModifiers_30()
 public interface I1
 {
     protected internal abstract int P1 {get; set;} 
+
+    sealed void Test()
+    {
+        P1 = P1;
+    }
 }
 ";
 
@@ -17917,24 +18251,33 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.Test();
     }
 
     public int P1 
     {
-        get => 0;
-        set {}
+        get
+        {
+            System.Console.WriteLine(""get_P1"");
+            return 0;
+        }
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_01(source1, source2, Accessibility.ProtectedOrInternal,
                 new DiagnosticDescription[] {
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 15)
                 },
                 // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
                 // class Test2 : I1
@@ -17950,6 +18293,11 @@ public void PropertyModifiers_31()
 public interface I1
 {
     private protected abstract int P1 {get; set;} 
+
+    sealed void Test()
+    {
+        P1 = P1;
+    }
 }
 ";
 
@@ -17959,24 +18307,33 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.Test();
     }
 
     public int P1 
     {
-        get => 0;
-        set {}
+        get
+        {
+            System.Console.WriteLine(""get_P1"");
+            return 0;
+        }
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_01(source1, source2, Accessibility.ProtectedAndInternal,
                 new DiagnosticDescription[] {
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 15)
                 },
                 // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
                 // class Test2 : I1
@@ -17992,6 +18349,11 @@ public void PropertyModifiers_32()
 public interface I1
 {
     abstract int P1 {protected get; set;} 
+
+    void M2()
+    {
+        P1 = P1;
+    }
 }
 ";
 
@@ -18001,19 +18363,28 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public int P1 
     {
-        get => 0;
-        set {}
+        get
+        {
+            System.Console.WriteLine(""get_P1"");
+            return 0;
+        }
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
             ValidatePropertyModifiers_23(source1, source2, Accessibility.Protected, Accessibility.Public,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -18025,6 +18396,11 @@ public void PropertyModifiers_33()
 public interface I1
 {
     abstract int P1 {protected internal get; set;} 
+
+    void M2()
+    {
+        P1 = P1;
+    }
 }
 ";
 
@@ -18034,19 +18410,28 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public int P1 
     {
-        get => 0;
-        set {}
+        get
+        {
+            System.Console.WriteLine(""get_P1"");
+            return 0;
+        }
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
             ValidatePropertyModifiers_23(source1, source2, Accessibility.ProtectedOrInternal, Accessibility.Public,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.get'. 'Test1.P1.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.get", "Test1.P1.get", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -18058,6 +18443,11 @@ public void PropertyModifiers_34()
 public interface I1
 {
     abstract int P1 {get; private protected set;} 
+
+    void M2()
+    {
+        P1 = P1;
+    }
 }
 ";
 
@@ -18067,19 +18457,28 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public int P1 
     {
-        get => 0;
-        set {}
+        get
+        {
+            System.Console.WriteLine(""get_P1"");
+            return 0;
+        }
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
             ValidatePropertyModifiers_23(source1, source2, Accessibility.Public, Accessibility.ProtectedAndInternal,
-                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.set'. 'Test1.P1.set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.set", "Test1.P1.set", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -19901,12 +20300,12 @@ public int this[int x]
 
             ValidatePropertyModifiers_11_01(source1, source2, Accessibility.Internal,
                 new DiagnosticDescription[] {
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 15)
                 },
                 // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.this[int]'
                 // class Test2 : I1
@@ -19955,12 +20354,12 @@ public virtual int this[int x]
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -20057,24 +20456,24 @@ public int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -20124,24 +20523,24 @@ public virtual int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -20196,24 +20595,24 @@ public override int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test3.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test3.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 22)
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // class Test1 : Test2, I1, I2
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // class Test1 : Test2, I1, I2
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -20263,12 +20662,12 @@ public int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
@@ -20280,12 +20679,12 @@ public interface I2
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1, I2
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1, I2
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -20390,9 +20789,9 @@ public virtual long this[int x]
 ";
 
             ValidatePropertyModifiers_11_09(source1, source2,
-                // (2,15): error CS0535: 'Test1' does not implement interface member 'I1.this[int]'
+                // (2,15): error CS0738: 'Test1' does not implement interface member 'I1.this[int]'. 'Test1.this[int]' cannot implement 'I1.this[int]' because it does not have the matching return type of 'int'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.this[int]").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.this[int]", "Test1.this[int]", "int").WithLocation(2, 15)
                 );
         }
 
@@ -20404,6 +20803,11 @@ public void IndexerModifiers_11_10()
 public interface I1
 {
     internal abstract int this[int x] {get; set;} 
+
+    sealed void Test()
+    {
+        this[0] = this[0];
+    }
 }
 ";
 
@@ -20415,23 +20819,32 @@ public int this[int x]
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_10(source1, source2,
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.this[int].set'. 'Test2.this[int].set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.this[int].set'. 'Test2.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].set", "Test2.this[int].set").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.this[int].get'. 'Test2.this[int].get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].set", "Test2.this[int].set", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.this[int].get'. 'Test2.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].get", "Test2.this[int].get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].get", "Test2.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -20443,6 +20856,11 @@ public void IndexerModifiers_11_11()
 public interface I1
 {
     internal abstract int this[int x] {get; set;} 
+
+    sealed void Test()
+    {
+        this[0] = this[0];
+    }
 }
 public class Test2 : I1
 {
@@ -20450,9 +20868,13 @@ public int this[int x]
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
@@ -20461,16 +20883,21 @@ public int this[int x]
 @"
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_11(source1, source2,
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.this[int].set'. 'Test2.this[int].set' cannot implicitly implement a non-public member.
+                // (11,22): error CS8704: 'Test2' does not implement interface member 'I1.this[int].get'. 'Test2.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].set", "Test2.this[int].set").WithLocation(6, 22),
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.this[int].get'. 'Test2.this[int].get' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].get", "Test2.this[int].get", "9.0", "10.0").WithLocation(11, 22),
+                // (11,22): error CS8704: 'Test2' does not implement interface member 'I1.this[int].set'. 'Test2.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].get", "Test2.this[int].get").WithLocation(6, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].set", "Test2.this[int].set", "9.0", "10.0").WithLocation(11, 22)
                 );
         }
 
@@ -22253,6 +22680,8 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public int this[int x] 
@@ -22270,9 +22699,9 @@ public int this[int x]
 }
 ";
             ValidatePropertyModifiers_23(source1, source2, Accessibility.Internal, Accessibility.Public,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -22317,9 +22746,9 @@ public virtual int this[int x]
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -22416,21 +22845,21 @@ public int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -22480,21 +22909,21 @@ public virtual int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -22549,21 +22978,21 @@ public override int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test3.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test3.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -22613,12 +23042,12 @@ public int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
@@ -22630,9 +23059,9 @@ public interface I2
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].get'. 'Test1.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1, I2
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].get", "Test1.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -22737,9 +23166,9 @@ public virtual long this[int x]
 ";
 
             ValidatePropertyModifiers_11_09(source1, source2,
-                // (2,15): error CS0535: 'Test1' does not implement interface member 'I1.this[int]'
+                // (2,15): error CS0738: 'Test1' does not implement interface member 'I1.this[int]'. 'Test1.this[int]' cannot implement 'I1.this[int]' because it does not have the matching return type of 'int'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.this[int]").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.this[int]", "Test1.this[int]", "int").WithLocation(2, 15)
                 );
         }
 
@@ -22751,6 +23180,11 @@ public void IndexerModifiers_23_10()
 public interface I1
 {
     abstract int this[int x] {internal get; set;} 
+
+    sealed void Test()
+    {
+        this[0] = this[0];
+    }
 }
 ";
 
@@ -22762,20 +23196,29 @@ public int this[int x]
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_10(source1, source2,
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.this[int].get'. 'Test2.this[int].get' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.this[int].get'. 'Test2.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].get", "Test2.this[int].get").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].get", "Test2.this[int].get", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -22787,6 +23230,11 @@ public void IndexerModifiers_23_11()
 public interface I1
 {
     abstract int this[int x] {internal get; set;} 
+
+    sealed void Test()
+    {
+        this[0] = this[0];
+    }
 }
 public class Test2 : I1
 {
@@ -22794,9 +23242,13 @@ public int this[int x]
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
@@ -22805,13 +23257,18 @@ public int this[int x]
 @"
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_11(source1, source2,
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.this[int].get'. 'Test2.this[int].get' cannot implicitly implement a non-public member.
+                // (11,22): error CS8704: 'Test2' does not implement interface member 'I1.this[int].get'. 'Test2.this[int].get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].get", "Test2.this[int].get").WithLocation(6, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].get", "Test2.this[int].get", "9.0", "10.0").WithLocation(11, 22)
                 );
         }
 
@@ -22837,6 +23294,8 @@ class Test1 : I1
 {
     static void Main()
     {
+        I1 x = new Test1();
+        x.M2();
     }
 
     public int this[int x] 
@@ -22854,9 +23313,9 @@ public int this[int x]
 }
 ";
             ValidatePropertyModifiers_23(source1, source2, Accessibility.Public, Accessibility.Internal,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -22901,9 +23360,9 @@ public virtual int this[int x]
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -23000,21 +23459,21 @@ public int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -23064,21 +23523,21 @@ public virtual int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -23133,21 +23592,21 @@ public override int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test3.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test3.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -23197,12 +23656,12 @@ public int this[int x]
     {
         get
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
         set
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
@@ -23214,9 +23673,9 @@ public interface I2
 ";
 
             ValidatePropertyModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.this[int].set'. 'Test1.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1, I2
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.this[int].set", "Test1.this[int].set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -23321,9 +23780,9 @@ public virtual long this[int x]
 ";
 
             ValidatePropertyModifiers_11_09(source1, source2,
-                // (2,15): error CS0535: 'Test1' does not implement interface member 'I1.this[int]'
+                // (2,15): error CS0738: 'Test1' does not implement interface member 'I1.this[int]'. 'Test1.this[int]' cannot implement 'I1.this[int]' because it does not have the matching return type of 'int'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.this[int]").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.this[int]", "Test1.this[int]", "int").WithLocation(2, 15)
                 );
         }
 
@@ -23335,6 +23794,11 @@ public void IndexerModifiers_23_60()
 public interface I1
 {
     abstract int this[int x] {get; internal set;} 
+
+    sealed void Test()
+    {
+        this[0] = this[0];
+    }
 }
 ";
 
@@ -23346,20 +23810,29 @@ public int this[int x]
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_10(source1, source2,
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.this[int].set'. 'Test2.this[int].set' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.this[int].set'. 'Test2.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].set", "Test2.this[int].set").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].set", "Test2.this[int].set", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -23371,6 +23844,11 @@ public void IndexerModifiers_23_61()
 public interface I1
 {
     abstract int this[int x] {get; internal set;} 
+
+    sealed void Test()
+    {
+        this[0] = this[0];
+    }
 }
 public class Test2 : I1
 {
@@ -23378,9 +23856,13 @@ public int this[int x]
     {
         get
         {
+            System.Console.WriteLine(""get_P1"");
             return 0;
         }
-        set {}
+        set
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
@@ -23389,13 +23871,18 @@ public int this[int x]
 @"
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidatePropertyModifiers_11_11(source1, source2,
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.this[int].set'. 'Test2.this[int].set' cannot implicitly implement a non-public member.
+                // (11,22): error CS8704: 'Test2' does not implement interface member 'I1.this[int].set'. 'Test2.this[int].set' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].set", "Test2.this[int].set").WithLocation(6, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.this[int].set", "Test2.this[int].set", "9.0", "10.0").WithLocation(11, 22)
                 );
         }
 
@@ -24102,9 +24589,9 @@ extern event System.Action P11 {add{} remove{}}
                 // (8,38): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     private event System.Action P05 {remove{}}
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "remove").WithArguments("default interface implementation", "8.0").WithLocation(8, 38),
-                // (9,37): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                // (9,32): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     static event System.Action P06 {add{}}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "add").WithArguments("default interface implementation", "8.0").WithLocation(9, 37),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "P06").WithArguments("default interface implementation", "8.0").WithLocation(9, 32),
                 // (10,38): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     virtual event System.Action P07 {remove{}}
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "remove").WithArguments("default interface implementation", "8.0").WithLocation(10, 38),
@@ -24891,7 +25378,7 @@ class Test2 : I1
 {}
 ";
             var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
 
             compilation1.VerifyDiagnostics(
@@ -24901,15 +25388,15 @@ class Test2 : I1
                 // (8,54): error CS0073: An add or remove accessor must have a body
                 //     sealed static event System.Action P3 {add; remove;}
                 Diagnostic(ErrorCode.ERR_AddRemoveMustHaveBody, ";").WithLocation(8, 54),
-                // (6,40): error CS0112: A static member 'I1.P2' cannot be marked as override, virtual, or abstract
+                // (6,40): error CS0112: A static member cannot be marked as 'virtual'
                 //     virtual static event System.Action P2 {add {} remove{}} 
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P2").WithArguments("I1.P2").WithLocation(6, 40),
-                // (8,39): error CS0238: 'I1.P3' cannot be sealed because it is not an override
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P2").WithArguments("virtual").WithLocation(6, 40),
+                // (8,39): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     sealed static event System.Action P3 {add; remove;}
-                Diagnostic(ErrorCode.ERR_SealedNonOverride, "P3").WithArguments("I1.P3").WithLocation(8, 39),
-                // (4,41): error CS0112: A static member 'I1.P1' cannot be marked as override, virtual, or abstract
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P3").WithArguments("sealed", "9.0", "preview").WithLocation(8, 39),
+                // (4,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     abstract static event System.Action P1; 
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P1").WithArguments("I1.P1").WithLocation(4, 41),
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P1").WithArguments("abstract", "9.0", "preview").WithLocation(4, 41),
                 // (13,28): error CS0539: 'Test1.P1' in explicit interface declaration is not found among members of the interface that can be implemented
                 //     event System.Action I1.P1 {add {} remove{}} 
                 Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "P1").WithArguments("Test1.P1").WithLocation(13, 28),
@@ -24918,7 +25405,13 @@ class Test2 : I1
                 Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "P2").WithArguments("Test1.P2").WithLocation(14, 28),
                 // (15,28): error CS0539: 'Test1.P3' in explicit interface declaration is not found among members of the interface that can be implemented
                 //     event System.Action I1.P3 {add {} remove{}} 
-                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "P3").WithArguments("Test1.P3").WithLocation(15, 28)
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "P3").WithArguments("Test1.P3").WithLocation(15, 28),
+                // (18,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
+                // class Test2 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test2", "I1.P1").WithLocation(18, 15),
+                // (11,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
+                // class Test1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.P1").WithLocation(11, 15)
                 );
 
             var test1 = compilation1.GetTypeByMetadataName("Test1");
@@ -24953,7 +25446,7 @@ void ValidateAccessor1(MethodSymbol accessor)
             var p2 = i1.GetMember<EventSymbol>("P2");
 
             Assert.False(p2.IsAbstract);
-            Assert.True(p2.IsVirtual);
+            Assert.False(p2.IsVirtual);
             Assert.False(p2.IsSealed);
             Assert.True(p2.IsStatic);
             Assert.False(p2.IsExtern);
@@ -24966,8 +25459,8 @@ void ValidateAccessor1(MethodSymbol accessor)
             void ValidateAccessor2(MethodSymbol accessor)
             {
                 Assert.False(accessor.IsAbstract);
-                Assert.True(accessor.IsVirtual);
-                Assert.True(accessor.IsMetadataVirtual());
+                Assert.False(accessor.IsVirtual);
+                Assert.False(accessor.IsMetadataVirtual());
                 Assert.False(accessor.IsSealed);
                 Assert.True(accessor.IsStatic);
                 Assert.False(accessor.IsExtern);
@@ -24981,7 +25474,7 @@ void ValidateAccessor2(MethodSymbol accessor)
 
             Assert.False(p3.IsAbstract);
             Assert.False(p3.IsVirtual);
-            Assert.True(p3.IsSealed);
+            Assert.False(p3.IsSealed);
             Assert.True(p3.IsStatic);
             Assert.False(p3.IsExtern);
             Assert.False(p3.IsOverride);
@@ -24995,7 +25488,7 @@ void ValidateAccessor3(MethodSymbol accessor)
                 Assert.False(accessor.IsAbstract);
                 Assert.False(accessor.IsVirtual);
                 Assert.False(accessor.IsMetadataVirtual());
-                Assert.True(accessor.IsSealed);
+                Assert.False(accessor.IsSealed);
                 Assert.True(accessor.IsStatic);
                 Assert.False(accessor.IsExtern);
                 Assert.False(accessor.IsAsync);
@@ -25333,12 +25826,12 @@ public event System.Action P1
             ValidateEventModifiers_11(source1, source2, Accessibility.Internal,
                 new DiagnosticDescription[]
                 {
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add", "9.0", "10.0").WithLocation(2, 15)
                 },
                 // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
                 // class Test2 : I1
@@ -25349,13 +25842,24 @@ public event System.Action P1
         private void ValidateEventModifiers_11(string source1, string source2, Accessibility accessibility, DiagnosticDescription[] expected1, params DiagnosticDescription[] expected2)
         {
             var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation1.VerifyDiagnostics(expected1);
 
             Validate1(compilation1.SourceModule);
 
+            compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+            Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                             verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => Validate1(m)).VerifyDiagnostics();
+
+            Validate1(compilation1.SourceModule);
+
             void Validate1(ModuleSymbol m)
             {
                 var test1 = m.GlobalNamespace.GetTypeMember("Test1");
@@ -25411,22 +25915,6 @@ void ValidateMethod(MethodSymbol m1)
                 ValidateMethod(p1.RemoveMethod);
             }
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation3.VerifyDiagnostics(expected1);
-
-            Validate1(compilation3.SourceModule);
-
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation4.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation4.VerifyDiagnostics(expected1);
-
-            Validate1(compilation4.SourceModule);
-
             var source3 =
 @"
 class Test2 : I1
@@ -25434,21 +25922,35 @@ class Test2 : I1
 }
 ";
 
-            var compilation5 = CreateCompilation(source3, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation5.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation5.VerifyDiagnostics(expected2);
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                compilation3.VerifyDiagnostics(expected1);
 
-            ValidateEventNotImplemented_11(compilation5, "Test2");
+                Validate1(compilation3.SourceModule);
 
-            var compilation6 = CreateCompilation(source3, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugDll,
+                compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
                                                  parseOptions: TestOptions.Regular,
                                                  targetFramework: TargetFramework.NetCoreApp);
-            Assert.True(compilation6.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
-            compilation6.VerifyDiagnostics(expected2);
+                Assert.True(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                                 verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => Validate1(m)).VerifyDiagnostics();
+
+                Validate1(compilation3.SourceModule);
+
+                var compilation5 = CreateCompilation(source3, new[] { reference }, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.Regular,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+                Assert.True(compilation5.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
+                compilation5.VerifyDiagnostics(expected2);
 
-            ValidateEventNotImplemented_11(compilation6, "Test2");
+                ValidateEventNotImplemented_11(compilation5, "Test2");
+            }
         }
 
         private static void ValidateEventNotImplemented_11(CSharpCompilation compilation, string className)
@@ -25505,12 +26007,12 @@ public virtual event System.Action P1
 ";
 
             ValidateEventModifiers_11_02(source1, source2,
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add", "9.0", "10.0").WithLocation(2, 15)
                 );
         }
 
@@ -25518,30 +26020,51 @@ private void ValidateEventModifiers_11_02(string source1, string source2,
                                                   params DiagnosticDescription[] expected)
         {
             var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular);
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
             compilation1.VerifyDiagnostics(expected);
 
             ValidateEventImplementation_11(compilation1.SourceModule);
 
+            compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                             verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateEventImplementation_11(m)).VerifyDiagnostics();
+
+            ValidateEventImplementation_11(compilation1.SourceModule);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
             compilation2.VerifyDiagnostics();
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular);
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
 
-            compilation3.VerifyDiagnostics(expected);
+                compilation3.VerifyDiagnostics(expected);
 
-            ValidateEventImplementation_11(compilation3.SourceModule);
+                ValidateEventImplementation_11(compilation3.SourceModule);
 
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular);
+                compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
-            compilation4.VerifyDiagnostics(expected);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                                 verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateEventImplementation_11(m)).VerifyDiagnostics();
 
-            ValidateEventImplementation_11(compilation4.SourceModule);
+                ValidateEventImplementation_11(compilation3.SourceModule);
+            }
         }
 
         private static void ValidateEventImplementation_11(ModuleSymbol m)
@@ -25568,11 +26091,8 @@ private static void ValidateEventImplementation_11(ModuleSymbol m, bool implemen
             Assert.Same(test1P1.AddMethod, test1.FindImplementationForInterfaceMember(p1Add));
             Assert.Same(test1P1.RemoveMethod, test1.FindImplementationForInterfaceMember(p1Remove));
 
-            var i2 = test1.InterfacesNoUseSiteDiagnostics().Where(i => i.Name == "I2").SingleOrDefault();
-            bool isMetadataVirtual = test1P1.IsVirtual || test1P1.IsAbstract || test1P1.IsExplicitInterfaceImplementation ||
-                (!implementedByBase && (object)i2 != null && (object)test1P1 == test1.FindImplementationForInterfaceMember(GetSingleEvent(i2)));
-            Assert.Equal(isMetadataVirtual, test1P1.AddMethod.IsMetadataVirtual());
-            Assert.Equal(isMetadataVirtual, test1P1.RemoveMethod.IsMetadataVirtual());
+            Assert.True(test1P1.AddMethod.IsMetadataVirtual());
+            Assert.True(test1P1.RemoveMethod.IsMetadataVirtual());
         }
 
         [Fact]
@@ -25708,23 +26228,23 @@ public event System.Action P1
     {
         add
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
         }
         remove
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidateEventModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -25776,23 +26296,23 @@ public virtual event System.Action P1
     {
         add
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
         }
         remove
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
 ";
 
             ValidateEventModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -25849,11 +26369,11 @@ public override event System.Action P1
     {
         add
         {
-            System.Console.WriteLine(""Test3.get_P1"");
+            System.Console.WriteLine(""get_P1"");
         }
         remove
         {
-            System.Console.WriteLine(""Test3.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
@@ -25861,12 +26381,12 @@ public override event System.Action P1
 ";
 
             ValidateEventModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -25918,11 +26438,11 @@ public event System.Action P1
     {
         add
         {
-            System.Console.WriteLine(""Test1.get_P1"");
+            System.Console.WriteLine(""get_P1"");
         }
         remove
         {
-            System.Console.WriteLine(""Test1.set_P1"");
+            System.Console.WriteLine(""set_P1"");
         }
     }
 }
@@ -25934,12 +26454,12 @@ public interface I2
 ";
 
             ValidateEventModifiers_11_02(source1, source2,
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member.
-                // class Test1 : Test2, I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add").WithLocation(2, 22)
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // class Test1 : Test2, I1, I2
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // class Test1 : Test2, I1, I2
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -26083,9 +26603,9 @@ public virtual event System.Action<object> P1
 ";
 
             ValidateEventModifiers_11_09(source1, source2,
-                // (2,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
+                // (2,15): error CS0738: 'Test1' does not implement interface member 'I1.P1'. 'Test1.P1' cannot implement 'I1.P1' because it does not have the matching return type of 'Action'.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("Test1", "I1.P1").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("Test1", "I1.P1", "Test1.P1", "System.Action").WithLocation(2, 15)
                 );
         }
 
@@ -26127,6 +26647,12 @@ public void EventModifiers_11_10()
 public interface I1
 {
     internal abstract event System.Action P1; 
+
+    sealed void Test()
+    {
+        P1 += null;
+        P1 -= null;
+    }
 }
 ";
 
@@ -26136,22 +26662,33 @@ public class Test2 : I1
 {
     public event System.Action P1 
     {
-        add {}
-        remove {}
+        add
+        {
+            System.Console.WriteLine(""get_P1"");
+        }
+        remove
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidateEventModifiers_11_10(source1, source2,
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.remove'. 'Test2.P1.remove' cannot implicitly implement a non-public member.
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.remove'. 'Test2.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.remove", "Test2.P1.remove").WithLocation(2, 22),
-                // (2,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.add'. 'Test2.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.remove", "Test2.P1.remove", "9.0", "10.0").WithLocation(2, 22),
+                // (2,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.add'. 'Test2.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.add", "Test2.P1.add").WithLocation(2, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.add", "Test2.P1.add", "9.0", "10.0").WithLocation(2, 22)
                 );
         }
 
@@ -26159,30 +26696,51 @@ private void ValidateEventModifiers_11_10(string source1, string source2,
                                                      params DiagnosticDescription[] expected)
         {
             var compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
             compilation1.VerifyDiagnostics(expected);
 
             ValidateEventImplementationByBase_11(compilation1.SourceModule);
 
+            compilation1 = CreateCompilation(source2 + source1, options: TestOptions.DebugExe,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                             verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateEventImplementationByBase_11(m)).VerifyDiagnostics();
+
+            ValidateEventImplementationByBase_11(compilation1.SourceModule);
+
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
             compilation2.VerifyDiagnostics();
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            foreach (var reference in new[] { compilation2.ToMetadataReference(), compilation2.EmitToImageReference() })
+            {
+                var compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
 
-            compilation3.VerifyDiagnostics(expected);
+                compilation3.VerifyDiagnostics(expected);
 
-            ValidateEventImplementationByBase_11(compilation3.SourceModule);
+                ValidateEventImplementationByBase_11(compilation3.SourceModule);
 
-            var compilation4 = CreateCompilation(source2, new[] { compilation2.EmitToImageReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+                compilation3 = CreateCompilation(source2, new[] { reference }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
-            compilation4.VerifyDiagnostics(expected);
+                CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                                 verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateEventImplementationByBase_11(m)).VerifyDiagnostics();
 
-            ValidateEventImplementationByBase_11(compilation4.SourceModule);
+                ValidateEventImplementationByBase_11(compilation3.SourceModule);
+            }
         }
 
         [Fact]
@@ -26193,13 +26751,25 @@ public void EventModifiers_11_11()
 public interface I1
 {
     internal abstract event System.Action P1; 
+
+    sealed void Test()
+    {
+        P1 += null;
+        P1 -= null;
+    }
 }
 public class Test2 : I1
 {
     public event System.Action P1 
     {
-        add {}
-        remove {}
+        add
+        {
+            System.Console.WriteLine(""get_P1"");
+        }
+        remove
+        {
+            System.Console.WriteLine(""set_P1"");
+        }
     }
 }
 ";
@@ -26208,16 +26778,21 @@ public event System.Action P1
 @"
 class Test1 : Test2, I1
 {
+    static void Main()
+    {
+        I1 x = new Test1();
+        x.Test();
+    }
 }
 ";
 
             ValidateEventModifiers_11_11(source1, source2,
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.remove'. 'Test2.P1.remove' cannot implicitly implement a non-public member.
+                // (12,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.remove'. 'Test2.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.remove", "Test2.P1.remove").WithLocation(6, 22),
-                // (6,22): error CS8504: 'Test2' does not implement interface member 'I1.P1.add'. 'Test2.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.remove", "Test2.P1.remove", "9.0", "10.0").WithLocation(12, 22),
+                // (12,22): error CS8704: 'Test2' does not implement interface member 'I1.P1.add'. 'Test2.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class Test2 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.add", "Test2.P1.add").WithLocation(6, 22)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test2", "I1.P1.add", "Test2.P1.add", "9.0", "10.0").WithLocation(12, 22)
                 );
         }
 
@@ -26225,23 +26800,29 @@ private void ValidateEventModifiers_11_11(string source1, string source2,
                                                      params DiagnosticDescription[] expected)
         {
             var compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
                                                  assemblyName: "EventModifiers_11_11");
 
             compilation2.VerifyDiagnostics(expected);
 
-            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            compilation2 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp,
+                                             assemblyName: "EventModifiers_11_11");
 
-            compilation3.VerifyDiagnostics();
+            compilation2.VerifyDiagnostics();
 
-            ValidateEventImplementationByBase_11(compilation3.SourceModule);
+            var compilation3 = CreateCompilation(source2, new[] { compilation2.ToMetadataReference() }, options: TestOptions.DebugExe,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
 
-            var compilation3Ref = compilation3.EmitToImageReference();
-            var compilation4 = CreateCompilation("", new[] { compilation2.ToMetadataReference(), compilation3Ref }, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular);
+            CompileAndVerify(compilation3, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"get_P1
+set_P1",
+                             verify: VerifyOnMonoOrCoreClr, symbolValidator: (m) => ValidateEventImplementationByBase_11(m)).VerifyDiagnostics();
 
-            ValidateEventImplementationByBase_11(compilation4.GetReferencedAssemblySymbol(compilation3Ref).Modules[0]);
+            ValidateEventImplementationByBase_11(compilation3.SourceModule);
         }
 
         [Fact]
@@ -27055,12 +27636,9 @@ void ValidateP5Accessor(MethodSymbol accessor)
                 // (20,39): error CS8703: The modifier 'extern' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     extern sealed event System.Action P5;
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P5").WithArguments("extern", "7.3", "8.0").WithLocation(20, 39),
-                // (26,9): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //         add => throw null;
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "add").WithArguments("default interface implementation", "8.0").WithLocation(26, 9),
-                // (27,9): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //         remove => throw null;
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "remove").WithArguments("default interface implementation", "8.0").WithLocation(27, 9),
+                // (24,32): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     static event System.Action P6
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "P6").WithArguments("default interface implementation", "8.0").WithLocation(24, 32),
                 // (8,40): warning CS0626: Method, operator, or accessor 'I2.P2.remove' is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation.
                 //     virtual extern event System.Action P2;
                 Diagnostic(ErrorCode.WRN_ExternMethodNoImplementation, "P2").WithArguments("I2.P2.remove").WithLocation(8, 40),
@@ -27379,9 +27957,9 @@ class Test2 : I1, I2, I3, I4, I5
                 // (16,44): error CS8712: 'I4.P4': abstract event cannot use event accessor syntax
                 //     abstract static event System.Action P4 { add {throw null;} remove {throw null;}}
                 Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I4.P4").WithLocation(16, 44),
-                // (16,41): error CS0112: A static member 'I4.P4' cannot be marked as override, virtual, or abstract
+                // (16,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
                 //     abstract static event System.Action P4 { add {throw null;} remove {throw null;}}
-                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P4").WithArguments("I4.P4").WithLocation(16, 41),
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P4").WithArguments("abstract", "9.0", "preview").WithLocation(16, 41),
                 // (20,41): error CS0106: The modifier 'override' is not valid for this item
                 //     override sealed event System.Action P5 { add {throw null;} remove {throw null;}}
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "P5").WithArguments("override").WithLocation(20, 41),
@@ -27406,6 +27984,12 @@ class Test2 : I1, I2, I3, I4, I5
                 // (12,39): warning CS0626: Method, operator, or accessor 'I3.P3.remove' is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation.
                 //     static extern event System.Action P3;
                 Diagnostic(ErrorCode.WRN_ExternMethodNoImplementation, "P3").WithArguments("I3.P3.remove").WithLocation(12, 39),
+                // (23,27): error CS0535: 'Test1' does not implement interface member 'I4.P4'
+                // class Test1 : I1, I2, I3, I4, I5
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I4").WithArguments("Test1", "I4.P4").WithLocation(23, 27),
+                // (27,27): error CS0535: 'Test2' does not implement interface member 'I4.P4'
+                // class Test2 : I1, I2, I3, I4, I5
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I4").WithArguments("Test2", "I4.P4").WithLocation(27, 27),
                 // (8,42): warning CS0067: The event 'I2.P2' is never used
                 //     abstract private event System.Action P2 = null; 
                 Diagnostic(ErrorCode.WRN_UnreferencedEvent, "P2").WithArguments("I2.P2").WithLocation(8, 42)
@@ -27415,7 +27999,7 @@ class Test2 : I1, I2, I3, I4, I5
         private void ValidateEventModifiers_18(string source1, params DiagnosticDescription[] expected)
         {
             var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
-                                                 parseOptions: TestOptions.Regular,
+                                                 parseOptions: TestOptions.Regular9,
                                                  targetFramework: TargetFramework.NetCoreApp);
             Assert.True(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation);
             compilation1.VerifyDiagnostics(expected);
@@ -28060,12 +28644,12 @@ public event System.Action P1
             ValidateEventModifiers_11(source1, source2, Accessibility.Protected,
                 new DiagnosticDescription[]
                 {
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add", "9.0", "10.0").WithLocation(2, 15)
                 },
                 // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
                 // class Test2 : I1
@@ -28117,12 +28701,12 @@ public event System.Action P1
             ValidateEventModifiers_11(source1, source2, Accessibility.ProtectedOrInternal,
                 new DiagnosticDescription[]
                 {
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add", "9.0", "10.0").WithLocation(2, 15)
                 },
                 // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
                 // class Test2 : I1
@@ -28174,12 +28758,12 @@ public event System.Action P1
             ValidateEventModifiers_11(source1, source2, Accessibility.ProtectedAndInternal,
                 new DiagnosticDescription[]
                 {
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member.
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.remove'. 'Test1.P1.remove' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove").WithLocation(2, 15),
-                // (2,15): error CS8504: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member.
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.remove", "Test1.P1.remove", "9.0", "10.0").WithLocation(2, 15),
+                // (2,15): error CS8704: 'Test1' does not implement interface member 'I1.P1.add'. 'Test1.P1.add' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // class Test1 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add").WithLocation(2, 15)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("Test1", "I1.P1.add", "Test1.P1.add", "9.0", "10.0").WithLocation(2, 15)
                 },
                 // (2,15): error CS0535: 'Test2' does not implement interface member 'I1.P1'
                 // class Test2 : I1
@@ -39260,48 +39844,24 @@ static void Main()
                 // (4,16): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     static int F1 {get; set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F1").WithArguments("static", "7.3", "8.0").WithLocation(4, 16),
-                // (4,20): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     static int F1 {get; set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(4, 20),
-                // (4,25): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     static int F1 {get; set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "set").WithArguments("default interface implementation", "8.0").WithLocation(4, 25),
                 // (5,23): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     public static int F2 {get; set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F2").WithArguments("static", "7.3", "8.0").WithLocation(5, 23),
                 // (5,23): error CS8703: The modifier 'public' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     public static int F2 {get; set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F2").WithArguments("public", "7.3", "8.0").WithLocation(5, 23),
-                // (5,27): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     public static int F2 {get; set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(5, 27),
-                // (5,32): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     public static int F2 {get; set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "set").WithArguments("default interface implementation", "8.0").WithLocation(5, 32),
                 // (6,25): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     internal static int F3 {get; set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F3").WithArguments("static", "7.3", "8.0").WithLocation(6, 25),
                 // (6,25): error CS8703: The modifier 'internal' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     internal static int F3 {get; set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F3").WithArguments("internal", "7.3", "8.0").WithLocation(6, 25),
-                // (6,29): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     internal static int F3 {get; set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(6, 29),
-                // (6,34): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     internal static int F3 {get; set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "set").WithArguments("default interface implementation", "8.0").WithLocation(6, 34),
                 // (7,24): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     private static int F4 {get; set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F4").WithArguments("static", "7.3", "8.0").WithLocation(7, 24),
                 // (7,24): error CS8703: The modifier 'private' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     private static int F4 {get; set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F4").WithArguments("private", "7.3", "8.0").WithLocation(7, 24),
-                // (7,28): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     private static int F4 {get; set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(7, 28),
-                // (7,33): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     private static int F4 {get; set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "set").WithArguments("default interface implementation", "8.0").WithLocation(7, 33),
                 // (9,18): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     public class TestHelper
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "TestHelper").WithArguments("default interface implementation", "8.0").WithLocation(9, 18)
@@ -39437,36 +39997,24 @@ static void Main()
                 // (4,16): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     static int F1 {get;} = 1;
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F1").WithArguments("static", "7.3", "8.0").WithLocation(4, 16),
-                // (4,20): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     static int F1 {get;} = 1;
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(4, 20),
                 // (5,23): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     public static int F2 {get;} = 2;
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F2").WithArguments("static", "7.3", "8.0").WithLocation(5, 23),
                 // (5,23): error CS8703: The modifier 'public' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     public static int F2 {get;} = 2;
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F2").WithArguments("public", "7.3", "8.0").WithLocation(5, 23),
-                // (5,27): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     public static int F2 {get;} = 2;
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(5, 27),
                 // (6,25): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     internal static int F3 {get;} = 3;
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F3").WithArguments("static", "7.3", "8.0").WithLocation(6, 25),
                 // (6,25): error CS8703: The modifier 'internal' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     internal static int F3 {get;} = 3;
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F3").WithArguments("internal", "7.3", "8.0").WithLocation(6, 25),
-                // (6,29): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     internal static int F3 {get;} = 3;
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(6, 29),
                 // (7,24): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     private static int F4 {get;} = 4;
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F4").WithArguments("static", "7.3", "8.0").WithLocation(7, 24),
                 // (7,24): error CS8703: The modifier 'private' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     private static int F4 {get;} = 4;
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F4").WithArguments("private", "7.3", "8.0").WithLocation(7, 24),
-                // (7,28): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     private static int F4 {get;} = 4;
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(7, 28),
                 // (9,18): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     public class TestHelper
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "TestHelper").WithArguments("default interface implementation", "8.0").WithLocation(9, 18)
@@ -39588,45 +40136,27 @@ static void Main()
                 // (4,16): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     static int F1 {get; private set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F1").WithArguments("static", "7.3", "8.0").WithLocation(4, 16),
-                // (4,20): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     static int F1 {get; private set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(4, 20),
                 // (4,33): error CS8703: The modifier 'private' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     static int F1 {get; private set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "set").WithArguments("private", "7.3", "8.0").WithLocation(4, 33),
-                // (4,33): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     static int F1 {get; private set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "set").WithArguments("default interface implementation", "8.0").WithLocation(4, 33),
                 // (5,23): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     public static int F2 {get; private set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F2").WithArguments("static", "7.3", "8.0").WithLocation(5, 23),
                 // (5,23): error CS8703: The modifier 'public' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     public static int F2 {get; private set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F2").WithArguments("public", "7.3", "8.0").WithLocation(5, 23),
-                // (5,27): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     public static int F2 {get; private set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(5, 27),
                 // (5,40): error CS8703: The modifier 'private' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     public static int F2 {get; private set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "set").WithArguments("private", "7.3", "8.0").WithLocation(5, 40),
-                // (5,40): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     public static int F2 {get; private set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "set").WithArguments("default interface implementation", "8.0").WithLocation(5, 40),
                 // (6,25): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     internal static int F3 {get; private set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F3").WithArguments("static", "7.3", "8.0").WithLocation(6, 25),
                 // (6,25): error CS8703: The modifier 'internal' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     internal static int F3 {get; private set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "F3").WithArguments("internal", "7.3", "8.0").WithLocation(6, 25),
-                // (6,29): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     internal static int F3 {get; private set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "get").WithArguments("default interface implementation", "8.0").WithLocation(6, 29),
                 // (6,42): error CS8703: The modifier 'private' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
                 //     internal static int F3 {get; private set;}
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "set").WithArguments("private", "7.3", "8.0").WithLocation(6, 42),
-                // (6,42): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
-                //     internal static int F3 {get; private set;}
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "set").WithArguments("default interface implementation", "8.0").WithLocation(6, 42),
                 // (8,18): error CS8652: The feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //     public class TestHelper
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "TestHelper").WithArguments("default interface implementation", "8.0").WithLocation(8, 18)
@@ -41168,33 +41698,46 @@ static void Main()
 ";
 
             var compilation1 = CreateCompilation(source1 + source2, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetCoreApp,
-                                                 parseOptions: TestOptions.Regular);
+                                                 parseOptions: TestOptions.Regular9);
             compilation1.VerifyDiagnostics(
-                // (4,31): error CS0567: Interfaces cannot contain conversion, equality, or inequality operators
+                // (4,31): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
                 //     public static I1 operator ==(I1 x, I1 y)
                 Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "==").WithLocation(4, 31),
-                // (10,31): error CS0567: Interfaces cannot contain conversion, equality, or inequality operators
+                // (10,31): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
                 //     public static I1 operator !=(I1 x, I1 y)
                 Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "!=").WithLocation(10, 31),
-                // (24,13): error CS0029: Cannot implicitly convert type 'bool' to 'I1'
+                // (24,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
                 //         x = x == y;
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x == y").WithArguments("bool", "I1").WithLocation(24, 13),
-                // (25,13): error CS0029: Cannot implicitly convert type 'bool' to 'I1'
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x == y").WithArguments("static abstract members in interfaces").WithLocation(24, 13),
+                // (25,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
                 //         x = x != y;
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x != y").WithArguments("bool", "I1").WithLocation(25, 13)
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x != y").WithArguments("static abstract members in interfaces").WithLocation(25, 13)
+                );
+
+            CreateCompilation(source1 + source2, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetCoreApp,
+                              parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
+                // (4,31): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     public static I1 operator ==(I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "==").WithLocation(4, 31),
+                // (10,31): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     public static I1 operator !=(I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "!=").WithLocation(10, 31)
                 );
 
             CompilationReference compilationReference = compilation1.ToMetadataReference();
 
             var compilation2 = CreateCompilation(source2, new[] { compilationReference }, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.Regular, targetFramework: TargetFramework.NetCoreApp);
-            compilation2.VerifyDiagnostics(
-                // (9,13): error CS0029: Cannot implicitly convert type 'bool' to 'I1'
+                                                 parseOptions: TestOptions.RegularPreview, targetFramework: TargetFramework.NetCoreApp);
+            compilation2.VerifyDiagnostics();
+
+            CreateCompilation(source2, new[] { compilationReference }, options: TestOptions.DebugExe,
+                              parseOptions: TestOptions.Regular9, targetFramework: TargetFramework.NetCoreApp).VerifyDiagnostics(
+                // (9,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
                 //         x = x == y;
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x == y").WithArguments("bool", "I1").WithLocation(9, 13),
-                // (10,13): error CS0029: Cannot implicitly convert type 'bool' to 'I1'
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x == y").WithArguments("static abstract members in interfaces").WithLocation(9, 13),
+                // (10,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
                 //         x = x != y;
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x != y").WithArguments("bool", "I1").WithLocation(10, 13)
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x != y").WithArguments("static abstract members in interfaces").WithLocation(10, 13)
                 );
 
             var ilSource = @"
@@ -41241,14 +41784,19 @@ .locals init (class I1 V_0)
 } // end of class I1
 ";
 
-            var compilation3 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugExe);
-            compilation3.VerifyDiagnostics(
-                // (9,13): error CS0029: Cannot implicitly convert type 'bool' to 'I1'
+            var compilation3 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugExe, parseOptions: TestOptions.RegularPreview);
+            CompileAndVerify(compilation3, verify: VerifyOnMonoOrCoreClr, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"
+==
+!=
+").VerifyDiagnostics();
+
+            CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
+                // (9,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
                 //         x = x == y;
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x == y").WithArguments("bool", "I1").WithLocation(9, 13),
-                // (10,13): error CS0029: Cannot implicitly convert type 'bool' to 'I1'
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x == y").WithArguments("static abstract members in interfaces").WithLocation(9, 13),
+                // (10,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
                 //         x = x != y;
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x != y").WithArguments("bool", "I1").WithLocation(10, 13)
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x != y").WithArguments("static abstract members in interfaces").WithLocation(10, 13)
                 );
 
             var source3 =
@@ -41265,12 +41813,23 @@ static void Main()
     }
 }
 ";
-            var compilation4 = CreateCompilationWithIL(source3, ilSource, options: TestOptions.DebugExe);
+            var compilation4 = CreateCompilationWithIL(source3, ilSource, options: TestOptions.DebugExe, parseOptions: TestOptions.RegularPreview);
             compilation4.VerifyDiagnostics();
             CompileAndVerify(compilation4, verify: VerifyOnMonoOrCoreClr, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"
-False
-True
+==
+Test2
+!=
+Test2
 ");
+
+            CreateCompilationWithIL(source3, ilSource, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
+                // (9,34): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         System.Console.WriteLine(x == y);
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x == y").WithArguments("static abstract members in interfaces").WithLocation(9, 34),
+                // (10,34): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         System.Console.WriteLine(x != y);
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x != y").WithArguments("static abstract members in interfaces").WithLocation(10, 34)
+                );
         }
 
         [Fact]
@@ -41302,10 +41861,16 @@ public static void Test(I1 x)
             var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll, targetFramework: TargetFramework.NetCoreApp,
                                                  parseOptions: TestOptions.Regular);
             compilation1.VerifyDiagnostics(
-                // (4,37): error CS0567: Interfaces cannot contain conversion, equality, or inequality operators
+                // (4,37): error CS0552: 'I1.implicit operator int(I1)': user-defined conversions to or from an interface are not allowed
+                //     public static implicit operator int(I1 x)
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I1.implicit operator int(I1)").WithLocation(4, 37),
+                // (4,37): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
                 //     public static implicit operator int(I1 x)
                 Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "int").WithLocation(4, 37),
-                // (8,37): error CS0567: Interfaces cannot contain conversion, equality, or inequality operators
+                // (8,37): error CS0552: 'I1.explicit operator byte(I1)': user-defined conversions to or from an interface are not allowed
+                //     public static explicit operator byte(I1 x)
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "byte").WithArguments("I1.explicit operator byte(I1)").WithLocation(8, 37),
+                // (8,37): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
                 //     public static explicit operator byte(I1 x)
                 Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "byte").WithLocation(8, 37),
                 // (15,17): error CS0029: Cannot implicitly convert type 'I1' to 'int'
@@ -43718,10 +44283,16 @@ static explicit operator byte(I1 x)
             }
 
             compilation1.VerifyDiagnostics(
-                // (4,30): error CS0567: Interfaces cannot contain conversion, equality, or inequality operators
+                // (4,30): error CS0552: 'I1.implicit operator int(I1)': user-defined conversions to or from an interface are not allowed
+                //     static implicit operator int(I1 x)
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I1.implicit operator int(I1)").WithLocation(4, 30),
+                // (4,30): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
                 //     static implicit operator int(I1 x)
                 Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "int").WithLocation(4, 30),
-                // (9,30): error CS0567: Interfaces cannot contain conversion, equality, or inequality operators
+                // (9,30): error CS0552: 'I1.explicit operator byte(I1)': user-defined conversions to or from an interface are not allowed
+                //     static explicit operator byte(I1 x)
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "byte").WithArguments("I1.explicit operator byte(I1)").WithLocation(9, 30),
+                // (9,30): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
                 //     static explicit operator byte(I1 x)
                 Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "byte").WithLocation(9, 30)
                 );
@@ -51839,6 +52410,9 @@ class Test1 : I2
                 // (4,25): error CS0065: 'I1.P1': event property must have both add and remove accessors
                 //     event System.Action P1 {add => throw null;}
                 Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "P1").WithArguments("I1.P1").WithLocation(4, 25),
+                // (9,37): error CS0550: 'I2.I1.P1.remove' adds an accessor not found in interface member 'I1.P1'
+                //     abstract event System.Action I1.P1;
+                Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "P1").WithArguments("I2.I1.P1.remove", "I1.P1").WithLocation(9, 37),
                 // (12,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
                 // class Test1 : I2
                 Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2").WithArguments("Test1", "I1.P1").WithLocation(12, 15)
@@ -51875,6 +52449,9 @@ class Test1 : I2
                 // (10,5): error CS8712: 'I2.I1.P1': abstract event cannot use event accessor syntax
                 //     {
                 Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I2.I1.P1").WithLocation(10, 5),
+                // (12,9): error CS0550: 'I2.I1.P1.remove' adds an accessor not found in interface member 'I1.P1'
+                //         remove {}
+                Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "remove").WithArguments("I2.I1.P1.remove", "I1.P1").WithLocation(12, 9),
                 // (16,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
                 // class Test1 : I2
                 Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2").WithArguments("Test1", "I1.P1").WithLocation(16, 15)
@@ -51904,6 +52481,9 @@ class Test1 : I2
                 // (4,25): error CS0065: 'I1.P1': event property must have both add and remove accessors
                 //     event System.Action P1 {remove => throw null;}
                 Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "P1").WithArguments("I1.P1").WithLocation(4, 25),
+                // (9,37): error CS0550: 'I2.I1.P1.add' adds an accessor not found in interface member 'I1.P1'
+                //     abstract event System.Action I1.P1;
+                Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "P1").WithArguments("I2.I1.P1.add", "I1.P1").WithLocation(9, 37),
                 // (12,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
                 // class Test1 : I2
                 Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2").WithArguments("Test1", "I1.P1").WithLocation(12, 15)
@@ -51940,6 +52520,9 @@ class Test1 : I2
                 // (10,5): error CS8712: 'I2.I1.P1': abstract event cannot use event accessor syntax
                 //     {
                 Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I2.I1.P1").WithLocation(10, 5),
+                // (11,9): error CS0550: 'I2.I1.P1.add' adds an accessor not found in interface member 'I1.P1'
+                //         add {}
+                Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "add").WithArguments("I2.I1.P1.add", "I1.P1").WithLocation(11, 9),
                 // (16,15): error CS0535: 'Test1' does not implement interface member 'I1.P1'
                 // class Test1 : I2
                 Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2").WithArguments("Test1", "I1.P1").WithLocation(16, 15)
@@ -55197,7 +55780,7 @@ static void Main()
     }
 }
 ";
-            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetCoreApp);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular9, targetFramework: TargetFramework.NetCoreApp);
 
             var i1M = compilation1.GetMember<MethodSymbol>("I1.M");
             var c0 = compilation1.GetTypeByMetadataName("C0");
@@ -55207,9 +55790,57 @@ static void Main()
             Assert.Equal("System.String C0.M()", test.FindImplementationForInterfaceMember(i1M).ToTestDisplayString());
 
             compilation1.VerifyDiagnostics(
-                // (15,19): error CS8704: 'C0' does not implement interface member 'I1.M()'. 'C0.M()' cannot implicitly implement a non-public member.
+                // (15,19): error CS8704: 'C0' does not implement interface member 'I1.M()'. 'C0.M()' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
                 // public class C0 : I1
-                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("C0", "I1.M()", "C0.M()").WithLocation(15, 19)
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("C0", "I1.M()", "C0.M()", "9.0", "10.0").WithLocation(15, 19)
+                );
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular, targetFramework: TargetFramework.NetCoreApp);
+
+            i1M = compilation1.GetMember<MethodSymbol>("I1.M");
+            c0 = compilation1.GetTypeByMetadataName("C0");
+            test = compilation1.GetTypeByMetadataName("Test");
+
+            Assert.Equal("System.String C0.M()", c0.FindImplementationForInterfaceMember(i1M).ToTestDisplayString());
+            Assert.Equal("System.String C0.M()", test.FindImplementationForInterfaceMember(i1M).ToTestDisplayString());
+
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "C0.M", verify: VerifyOnMonoOrCoreClr).VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void ImplicitImplementationOfNonPublicMethod_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    internal int get_P();
+}
+
+public class C0 : I1
+{
+    public virtual int P { get; }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (7,19): error CS8704: 'C0' does not implement interface member 'I1.get_P()'. 'C0.P.get' cannot implicitly implement a non-public member in C# 9.0. Please use language version '10.0' or greater.
+                // public class C0 : I1
+                Diagnostic(ErrorCode.ERR_ImplicitImplementationOfNonPublicInterfaceMember, "I1").WithArguments("C0", "I1.get_P()", "C0.P.get", "9.0", "10.0").WithLocation(7, 19),
+                // (9,28): error CS0686: Accessor 'C0.P.get' cannot implement interface member 'I1.get_P()' for type 'C0'. Use an explicit interface implementation.
+                //     public virtual int P { get; }
+                Diagnostic(ErrorCode.ERR_AccessorImplementingMethod, "get").WithArguments("C0.P.get", "I1.get_P()", "C0").WithLocation(9, 28)
+                );
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                             parseOptions: TestOptions.Regular,
+                                             targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (9,28): error CS0686: Accessor 'C0.P.get' cannot implement interface member 'I1.get_P()' for type 'C0'. Use an explicit interface implementation.
+                //     public virtual int P { get; }
+                Diagnostic(ErrorCode.ERR_AccessorImplementingMethod, "get").WithArguments("C0.P.get", "I1.get_P()", "C0").WithLocation(9, 28)
                 );
         }
 
@@ -59558,18 +60189,17 @@ interface I2<out T1, in T2>
                                                  parseOptions: TestOptions.Regular8,
                                                  targetFramework: TargetFramework.NetCoreApp);
             compilation1.VerifyDiagnostics(
-                // (15,12): error CS8904: Invalid variance: The type parameter 'T1' must be invariantly valid on 'I2<T1, T2>.P1' unless language version 'preview' or greater is used. 'T1' is covariant.
+                // (15,12): error CS8904: Invalid variance: The type parameter 'T1' must be invariantly valid on 'I2<T1, T2>.P1' unless language version '9.0' or greater is used. 'T1' is covariant.
                 //     static T1 P1 { get; set; }
-                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "T1").WithArguments("I2<T1, T2>.P1", "T1", "covariant", "invariantly", "preview").WithLocation(15, 12),
-                // (16,12): error CS8904: Invalid variance: The type parameter 'T2' must be invariantly valid on 'I2<T1, T2>.P2' unless language version 'preview' or greater is used. 'T2' is contravariant.
+                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "T1").WithArguments("I2<T1, T2>.P1", "T1", "covariant", "invariantly", "9.0").WithLocation(15, 12),
+                // (16,12): error CS8904: Invalid variance: The type parameter 'T2' must be invariantly valid on 'I2<T1, T2>.P2' unless language version '9.0' or greater is used. 'T2' is contravariant.
                 //     static T2 P2 { get; set; }
-                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "T2").WithArguments("I2<T1, T2>.P2", "T2", "contravariant", "invariantly", "preview").WithLocation(16, 12)
+                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "T2").WithArguments("I2<T1, T2>.P2", "T2", "contravariant", "invariantly", "9.0").WithLocation(16, 12)
                 );
 
             compilation1 = CreateCompilation(source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.RegularPreview,
-                                                 targetFramework: TargetFramework.NetCoreApp);
-
+                                                        parseOptions: TestOptions.Regular9,
+                                                        targetFramework: TargetFramework.NetCoreApp);
             CompileAndVerify(compilation1, verify: VerifyOnMonoOrCoreClr, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
 @"a
 b").VerifyDiagnostics();
@@ -59600,17 +60230,17 @@ interface I2<out T1, in T2>
                                                  parseOptions: TestOptions.Regular8,
                                                  targetFramework: TargetFramework.NetCoreApp);
             compilation1.VerifyDiagnostics(
-                // (13,18): error CS8904: Invalid variance: The type parameter 'T1' must be contravariantly valid on 'I2<T1, T2>.M1(T1)' unless language version 'preview' or greater is used. 'T1' is covariant.
+                // (13,18): error CS8904: Invalid variance: The type parameter 'T1' must be contravariantly valid on 'I2<T1, T2>.M1(T1)' unless language version '9.0' or greater is used. 'T1' is covariant.
                 //     static T1 M1(T1 x) => x;
-                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "T1").WithArguments("I2<T1, T2>.M1(T1)", "T1", "covariant", "contravariantly", "preview").WithLocation(13, 18),
-                // (14,12): error CS8904: Invalid variance: The type parameter 'T2' must be covariantly valid on 'I2<T1, T2>.M2(T2)' unless language version 'preview' or greater is used. 'T2' is contravariant.
+                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "T1").WithArguments("I2<T1, T2>.M1(T1)", "T1", "covariant", "contravariantly", "9.0").WithLocation(13, 18),
+                // (14,12): error CS8904: Invalid variance: The type parameter 'T2' must be covariantly valid on 'I2<T1, T2>.M2(T2)' unless language version '9.0' or greater is used. 'T2' is contravariant.
                 //     static T2 M2(T2 x) => x;
-                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "T2").WithArguments("I2<T1, T2>.M2(T2)", "T2", "contravariant", "covariantly", "preview").WithLocation(14, 12)
+                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "T2").WithArguments("I2<T1, T2>.M2(T2)", "T2", "contravariant", "covariantly", "9.0").WithLocation(14, 12)
                 );
 
             compilation1 = CreateCompilation(source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.RegularPreview,
-                                                 targetFramework: TargetFramework.NetCoreApp);
+                                            parseOptions: TestOptions.Regular9,
+                                            targetFramework: TargetFramework.NetCoreApp);
 
             CompileAndVerify(compilation1, verify: VerifyOnMonoOrCoreClr, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
 @"a
@@ -59664,17 +60294,17 @@ static T3 Print<T3>(T3 x)
                                                  parseOptions: TestOptions.Regular8,
                                                  targetFramework: TargetFramework.NetCoreApp);
             compilation1.VerifyDiagnostics(
-                // (24,53): error CS8904: Invalid variance: The type parameter 'T1' must be contravariantly valid on 'I2<T1, T2>.E1' unless language version 'preview' or greater is used. 'T1' is covariant.
+                // (24,53): error CS8904: Invalid variance: The type parameter 'T1' must be contravariantly valid on 'I2<T1, T2>.E1' unless language version '9.0' or greater is used. 'T1' is covariant.
                 //     static event System.Action<System.Func<T1, T1>> E1;
-                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "E1").WithArguments("I2<T1, T2>.E1", "T1", "covariant", "contravariantly", "preview").WithLocation(24, 53),
-                // (25,53): error CS8904: Invalid variance: The type parameter 'T2' must be covariantly valid on 'I2<T1, T2>.E2' unless language version 'preview' or greater is used. 'T2' is contravariant.
+                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "E1").WithArguments("I2<T1, T2>.E1", "T1", "covariant", "contravariantly", "9.0").WithLocation(24, 53),
+                // (25,53): error CS8904: Invalid variance: The type parameter 'T2' must be covariantly valid on 'I2<T1, T2>.E2' unless language version '9.0' or greater is used. 'T2' is contravariant.
                 //     static event System.Action<System.Func<T2, T2>> E2;
-                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "E2").WithArguments("I2<T1, T2>.E2", "T2", "contravariant", "covariantly", "preview").WithLocation(25, 53)
+                Diagnostic(ErrorCode.ERR_UnexpectedVarianceStaticMember, "E2").WithArguments("I2<T1, T2>.E2", "T2", "contravariant", "covariantly", "9.0").WithLocation(25, 53)
                 );
 
             compilation1 = CreateCompilation(source1, options: TestOptions.DebugExe,
-                                                 parseOptions: TestOptions.RegularPreview,
-                                                 targetFramework: TargetFramework.NetCoreApp);
+                                              parseOptions: TestOptions.Regular9,
+                                              targetFramework: TargetFramework.NetCoreApp);
 
             CompileAndVerify(compilation1, verify: VerifyOnMonoOrCoreClr, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
 @"a
@@ -60501,5 +61131,145 @@ static void Main()
                 expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : "Test",
                 verify: VerifyOnMonoOrCoreClr);
         }
+
+        [Fact, WorkItem(53565, "https://github.com/dotnet/roslyn/issues/53565")]
+        public void PartialPropertyImplementation_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    int P1 {get; set;}
+    int P2 {get => throw null; internal set{}}
+    int P3 {get => throw null; set{}}
+}
+
+class C0 : I1
+{
+    int I1.P1 {get; set;}
+}
+
+class C1 : C0, I1
+{
+    public int P1 
+    {
+        get 
+        {
+            System.Console.WriteLine(""C1.get_P1"");
+            return 0;
+        }
+    }
+    public int P2 
+    {
+        get 
+        {
+            System.Console.WriteLine(""C1.get_P2"");
+            return 0;
+        }
+    }
+    public int P3 
+    {
+        get 
+        {
+            System.Console.WriteLine(""C1.get_P3"");
+            return 0;
+        }
+    }
+
+    static void Main()
+    {
+        I1 x = new C1();
+        _ = x.P1;
+        _ = x.P2;
+        _ = x.P3;
+    }
+}
+";
+            foreach (var parseOptions in new[] { TestOptions.Regular8, TestOptions.Regular9, TestOptions.Regular })
+            {
+                var compilation1 = CreateCompilation(source1, options: TestOptions.DebugExe,
+                                                     parseOptions: parseOptions,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation1,
+                    expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"C1.get_P1
+C1.get_P2
+C1.get_P3
+",
+                    verify: VerifyOnMonoOrCoreClr);
+
+                var c1 = compilation1.GetTypeByMetadataName("C1");
+
+                foreach (var p in c1.GetMembers().OfType<PropertySymbol>())
+                {
+                    Assert.True(p.GetMethod.IsMetadataVirtual());
+                    Assert.True(p.GetMethod.IsMetadataFinal);
+                }
+            }
+        }
+
+        [Fact, WorkItem(53565, "https://github.com/dotnet/roslyn/issues/53565")]
+        public void PartialPropertyImplementation_02()
+        {
+            var source1 =
+@"
+interface I1
+{
+    internal int P1 {get; set;}
+    internal int P2 {get => throw null; set{}}
+}
+
+class C0 : I1
+{
+    int I1.P1 {get; set;}
+}
+
+class C1 : C0, I1
+{
+    public int P1 
+    {
+        get 
+        {
+            System.Console.WriteLine(""C1.get_P1"");
+            return 0;
+        }
+    }
+    public int P2 
+    {
+        get 
+        {
+            System.Console.WriteLine(""C1.get_P2"");
+            return 0;
+        }
+    }
+
+    static void Main()
+    {
+        I1 x = new C1();
+        _ = x.P1;
+        _ = x.P2;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugExe,
+                                                    parseOptions: TestOptions.Regular,
+                                                    targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1,
+                expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
+@"C1.get_P1
+C1.get_P2
+",
+                verify: VerifyOnMonoOrCoreClr);
+
+            var c1 = compilation1.GetTypeByMetadataName("C1");
+
+            foreach (var p in c1.GetMembers().OfType<PropertySymbol>())
+            {
+                Assert.True(p.GetMethod.IsMetadataVirtual());
+                Assert.True(p.GetMethod.IsMetadataFinal);
+            }
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
index d6377beb3b457..14146f5916534 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
@@ -1135,14 +1135,14 @@ static class S
     internal static object E(this object o) { return null; }
     private static object F(this object o) { return null; }
 }";
-            var compilation = CreateCompilation(source);
+            var compilation = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             compilation.VerifyDiagnostics(
                 // (5,9): error CS1656: Cannot assign to 'E' because it is a 'method group'
                 //         o.E += o.E;
                 Diagnostic(ErrorCode.ERR_AssgReadonlyLocalCause, "o.E").WithArguments("E", "method group").WithLocation(5, 9),
-                // (6,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (6,13): error CS8773: Feature 'inferred delegate type' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         if (o.E != null)
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "o.E").WithArguments("inferred delegate type").WithLocation(6, 13),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "o.E").WithArguments("inferred delegate type", "10.0").WithLocation(6, 13),
                 // (8,15): error CS1503: Argument 1: cannot convert from 'method group' to 'object'
                 //             M(o.E);
                 Diagnostic(ErrorCode.ERR_BadArgType, "o.E").WithArguments("1", "method group", "object").WithLocation(8, 15),
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/IndexerTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/IndexerTests.cs
index 421d76ae26e44..cf9f689556b1f 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/IndexerTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/IndexerTests.cs
@@ -145,7 +145,7 @@ public object this[string index]
             var sourceType = globalNamespace.GetMember<SourceNamedTypeSymbol>("B");
             CheckIndexer(sourceType.Indexers.Single(), true, true, SpecialType.System_Object, SpecialType.System_String);
 
-            var bridgeMethods = sourceType.GetSynthesizedExplicitImplementations(CancellationToken.None);
+            var bridgeMethods = sourceType.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods;
             Assert.Equal(2, bridgeMethods.Length);
             Assert.True(bridgeMethods.Select(GetPairForSynthesizedExplicitImplementation).SetEquals(new[]
             {
@@ -156,7 +156,7 @@ public object this[string index]
             sourceType = globalNamespace.GetMember<SourceNamedTypeSymbol>("C");
             CheckIndexer(sourceType.Indexers.Single(), true, true, SpecialType.System_Object, SpecialType.System_String);
 
-            bridgeMethods = sourceType.GetSynthesizedExplicitImplementations(CancellationToken.None);
+            bridgeMethods = sourceType.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods;
             Assert.Equal(3, bridgeMethods.Length);
             Assert.True(bridgeMethods.Select(GetPairForSynthesizedExplicitImplementation).SetEquals(new[]
             {
@@ -335,7 +335,7 @@ class C : I1, I2
             Assert.Equal(classIndexer, @class.FindImplementationForInterfaceMember(interface1Indexer));
             Assert.Equal(classIndexer, @class.FindImplementationForInterfaceMember(interface2Indexer));
 
-            var synthesizedExplicitImplementations = @class.GetSynthesizedExplicitImplementations(default(CancellationToken));
+            var synthesizedExplicitImplementations = @class.GetSynthesizedExplicitImplementations(default(CancellationToken)).ForwardingMethods;
             Assert.Equal(2, synthesizedExplicitImplementations.Length);
 
             Assert.Equal(classIndexer.GetMethod, synthesizedExplicitImplementations[0].ImplementingMethod);
@@ -417,7 +417,7 @@ class C : I1, I2
                 Assert.Equal(classIndexer, @class.FindImplementationForInterfaceMember(interface1Indexer));
                 Assert.Equal(classIndexer, @class.FindImplementationForInterfaceMember(interface2Indexer));
 
-                var synthesizedExplicitImplementations = @class.GetSynthesizedExplicitImplementations(default(CancellationToken));
+                var synthesizedExplicitImplementations = @class.GetSynthesizedExplicitImplementations(default(CancellationToken)).ForwardingMethods;
                 Assert.Equal(2, synthesizedExplicitImplementations.Length);
 
                 Assert.Equal(classIndexer.GetMethod, synthesizedExplicitImplementations[0].ImplementingMethod);
@@ -484,7 +484,7 @@ class C : I1
                 Assert.Equal(classIndexer, @class.FindImplementationForInterfaceMember(interfaceIndexers[0]));
                 Assert.Equal(classIndexer, @class.FindImplementationForInterfaceMember(interfaceIndexers[1]));
 
-                var synthesizedExplicitImplementation = @class.GetSynthesizedExplicitImplementations(default(CancellationToken)).Single();
+                var synthesizedExplicitImplementation = @class.GetSynthesizedExplicitImplementations(default(CancellationToken)).ForwardingMethods.Single();
 
                 Assert.Equal(classIndexer.GetMethod, synthesizedExplicitImplementation.ImplementingMethod);
 
@@ -524,14 +524,14 @@ .property instance int32 B(int32)
 } // end of class I1
 ";
 
-            var csharp = @"
+            var csharp1 = @"
 class C : I1
 {
     int I1.this[int x] { get { return 0; } }
 }
 ";
 
-            var compilation = CreateCompilationWithILAndMscorlib40(csharp, il).VerifyDiagnostics(
+            var compilation = CreateCompilationWithILAndMscorlib40(csharp1, il).VerifyDiagnostics(
                 // (4,12): warning CS0473: Explicit interface implementation 'C.I1.this[int]' matches more than one interface member. Which interface member is actually chosen is implementation-dependent. Consider using a non-explicit implementation instead.
                 Diagnostic(ErrorCode.WRN_ExplicitImplCollision, "this").WithArguments("C.I1.this[int]"),
                 // (2,7): error CS0535: 'C' does not implement interface member 'I1.this[int]'
@@ -551,6 +551,15 @@ class C : I1
             var indexer1Impl = @class.FindImplementationForInterfaceMember(interfaceIndexers[1]);
             Assert.True(indexer0Impl == classIndexer ^ indexer1Impl == classIndexer);
             Assert.True(indexer0Impl == null ^ indexer1Impl == null);
+
+            var csharp2 = @"
+class C : I1
+{
+    public int this[int x] { get { return 0; } }
+}
+";
+
+            compilation = CreateCompilationWithILAndMscorlib40(csharp2, il).VerifyDiagnostics();
         }
 
         [ClrOnlyFact(ClrOnlyReason.Ilasm)]
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/InterfaceImplementationTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/InterfaceImplementationTests.cs
index a90947f957bb3..d1469451ea66f 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/InterfaceImplementationTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/InterfaceImplementationTests.cs
@@ -939,7 +939,7 @@ public class Derived : Base, Interface
             Assert.True(((Cci.IMethodDefinition)baseClassPropertyGetter.GetCciAdapter()).IsVirtual);
             Assert.True(((Cci.IMethodDefinition)baseClassPropertySetter.GetCciAdapter()).IsVirtual);
 
-            Assert.False(derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None).Any());
+            Assert.False(derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Any());
         }
 
         [Fact]
@@ -1010,7 +1010,7 @@ public class Derived : Base, Interface
 
             // GetSynthesizedExplicitImplementations doesn't guarantee order, so sort to make the asserts easier to write.
 
-            var synthesizedExplicitImpls = (from m in derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None) orderby m.MethodKind select m).ToArray();
+            var synthesizedExplicitImpls = (from m in derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods orderby m.MethodKind select m).ToArray();
             Assert.Equal(3, synthesizedExplicitImpls.Length);
             Assert.True(synthesizedExplicitImpls.All(s => ReferenceEquals(derivedClass, s.ContainingType)));
 
@@ -1079,7 +1079,7 @@ class Class : CustomModifierOverridingD, Interface
 
             // GetSynthesizedExplicitImplementations doesn't guarantee order, so sort to make the asserts easier to write.
 
-            var synthesizedExplicitImpls = (from m in @class.GetSynthesizedExplicitImplementations(CancellationToken.None) orderby m.Name select m).ToArray();
+            var synthesizedExplicitImpls = (from m in @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods orderby m.Name select m).ToArray();
             Assert.Equal(2, synthesizedExplicitImpls.Length);
 
             var synthesizedExplicitMethod1Impl = synthesizedExplicitImpls[0];
@@ -1652,7 +1652,7 @@ class C : B, I { }
 
             Assert.Equal(classBMethod, classC.FindImplementationForInterfaceMember(interfaceMethod));
 
-            var synthesizedExplicitImpl = classC.GetSynthesizedExplicitImplementations(CancellationToken.None).Single();
+            var synthesizedExplicitImpl = classC.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single();
             Assert.Equal(classC, synthesizedExplicitImpl.ContainingType);
             Assert.Equal(interfaceMethod, synthesizedExplicitImpl.ExplicitInterfaceImplementations.Single());
             Assert.Equal(classBMethod, synthesizedExplicitImpl.ImplementingMethod);
@@ -1712,7 +1712,7 @@ class C : B, I { }
 
             Assert.Equal(classBMethod, classC.FindImplementationForInterfaceMember(interfaceMethod));
 
-            Assert.Equal(0, classC.GetSynthesizedExplicitImplementations(CancellationToken.None).Length);
+            Assert.Equal(0, classC.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length);
         }
 
         [Fact]
@@ -1897,7 +1897,7 @@ class D : B, I
             comp2.VerifyDiagnostics();
 
             var derivedType = comp2.GlobalNamespace.GetMember<SourceNamedTypeSymbol>("D");
-            var bridgeMethod = derivedType.GetSynthesizedExplicitImplementations(CancellationToken.None).Single();
+            var bridgeMethod = derivedType.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single();
             Assert.Equal("NonVirtual", bridgeMethod.ImplementingMethod.Name);
         }
 
@@ -2033,7 +2033,7 @@ public class D : B, I
             Assert.Equal(RefKind.Ref, baseMethod.RefKind);
             Assert.Equal(baseMethod, derivedType.FindImplementationForInterfaceMember(interfaceMethod));
 
-            var synthesized = derivedType.GetSynthesizedExplicitImplementations(CancellationToken.None).Single();
+            var synthesized = derivedType.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single();
             Assert.Equal(baseMethod, synthesized.ImplementingMethod);
             Assert.Equal(interfaceMethod, synthesized.ExplicitInterfaceImplementations.Single());
 
@@ -2705,7 +2705,7 @@ private void ExplicitImplementationInBaseType(
             CompileAndVerify(comp, expectedOutput: expectedOutput);
 
             var derivedType = comp.GetMember<SourceNamedTypeSymbol>(derivedTypeName);
-            Assert.True(derivedType.GetSynthesizedExplicitImplementations(cancellationToken: default).IsEmpty);
+            Assert.True(derivedType.GetSynthesizedExplicitImplementations(cancellationToken: default).ForwardingMethods.IsEmpty);
 
             var interfaceMember = comp.GetMember<MethodSymbol>(interfaceMemberName);
             var implementingMember = derivedType.FindImplementationForInterfaceMember(interfaceMember);
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/MockNamedTypeSymbol.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/MockNamedTypeSymbol.cs
index 6ecfc5fcaf518..bdb7812c8f2d7 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/MockNamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/MockNamedTypeSymbol.cs
@@ -328,5 +328,10 @@ internal override AttributeUsageInfo GetAttributeUsageInfo()
         internal override bool IsRecordStruct => false;
         internal override bool HasPossibleWellKnownCloneMethod() => false;
         internal override bool IsInterpolatedStringHandlerType => false;
+
+        internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/OverriddenOrHiddenMembersTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/OverriddenOrHiddenMembersTests.cs
index 897be18e1d5ac..ba49ee78ce9e3 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/OverriddenOrHiddenMembersTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/OverriddenOrHiddenMembersTests.cs
@@ -2025,7 +2025,7 @@ class B2 : B1, I1
 ";
             var comp = CreateCompilation(text);
             comp.VerifyDiagnostics(
-                // (10,16): error CS0736: 'B2' does not implement interface member 'I1.Goo'. 'B2.Goo' cannot implement an interface member because it is static.
+                // (10,16): error CS0736: 'B2' does not implement instance interface member 'I1.Goo'. 'B2.Goo' cannot implement the interface member because it is static.
                 // class B2 : B1, I1
                 Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "I1").WithArguments("B2", "I1.Goo", "B2.Goo").WithLocation(10, 16));
 
@@ -2064,10 +2064,10 @@ class B3 : I
     public static void M<T>() { }
 }";
             CreateCompilationWithILAndMscorlib40(csharpSource, ilSource).VerifyDiagnostics(
-                // (5,15): error CS0736: 'B2' does not implement interface member 'I.M<T>()'. 'A.M<T>()' cannot implement an interface member because it is static.
+                // (5,15): error CS0736: 'B2' does not implement instance interface member 'I.M<T>()'. 'A.M<T>()' cannot implement the interface member because it is static.
                 // class B2 : A, I
                 Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "I").WithArguments("B2", "I.M<T>()", "A.M<T>()").WithLocation(5, 15),
-                // (8,12): error CS0736: 'B3' does not implement interface member 'I.M<T>()'. 'B3.M<T>()' cannot implement an interface member because it is static.
+                // (8,12): error CS0736: 'B3' does not implement instance interface member 'I.M<T>()'. 'B3.M<T>()' cannot implement the interface member because it is static.
                 // class B3 : I
                 Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "I").WithArguments("B3", "I.M<T>()", "B3.M<T>()").WithLocation(8, 12));
         }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Retargeting/RetargetExplicitInterfaceImplementation.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Retargeting/RetargetExplicitInterfaceImplementation.cs
index dd9c78b23f953..3258c61bea7a9 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Retargeting/RetargetExplicitInterfaceImplementation.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Retargeting/RetargetExplicitInterfaceImplementation.cs
@@ -436,5 +436,40 @@ public  class D3 : C3
             var retargetedClassC3Event1Impl = retargetedClassC3Event1.ExplicitInterfaceImplementations.Single();
             Assert.Same(interfaceV2Event1, retargetedClassC3Event1Impl.OriginalDefinition);
         }
+
+        [Fact]
+        public void ExplicitInterfaceImplementationRetargetingGenericType()
+        {
+            var source1 = @"
+public class C1<T>
+{
+    public interface I1
+    {
+        void M(T x);
+    }
+}
+";
+            var ref1 = CreateEmptyCompilation("").ToMetadataReference();
+            var compilation1 = CreateCompilation(source1, references: new[] { ref1 });
+
+            var source2 = @"
+public class C2<U> : C1<U>.I1
+{
+    void C1<U>.I1.M(U x) {}
+}
+";
+            var compilation2 = CreateCompilation(source2, references: new[] { compilation1.ToMetadataReference(), ref1, CreateEmptyCompilation("").ToMetadataReference() });
+
+            var compilation3 = CreateCompilation("", references: new[] { compilation1.ToMetadataReference(), compilation2.ToMetadataReference() });
+
+            Assert.NotSame(compilation2.GetTypeByMetadataName("C1`1"), compilation3.GetTypeByMetadataName("C1`1"));
+
+            var c2 = compilation3.GetTypeByMetadataName("C2`1");
+            Assert.IsType<RetargetingNamedTypeSymbol>(c2);
+
+            var m = c2.GetMethod("C1<U>.I1.M");
+
+            Assert.Equal(c2.Interfaces().Single().GetMethod("M"), m.ExplicitInterfaceImplementations.Single());
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/CustomModifierCopyTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/CustomModifierCopyTests.cs
index dbf8e882f5f52..135c35ba5d853 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/CustomModifierCopyTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/CustomModifierCopyTests.cs
@@ -62,7 +62,7 @@ public void Method2(int x) { }
             AssertNoParameterHasModOpts(classMethod2);
 
             // bridge method for implicit implementation has custom modifiers
-            var method2ExplicitImpl = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).Single();
+            var method2ExplicitImpl = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single();
             Assert.Same(classMethod2, method2ExplicitImpl.ImplementingMethod);
             AssertAllParametersHaveConstModOpt(method2ExplicitImpl);
         }
@@ -109,7 +109,7 @@ public void Method2(int x) { }
             AssertNoParameterHasModOpts(classMethod2);
 
             // bridge methods for implicit implementation have custom modifiers
-            var method2ExplicitImpls = @class.GetSynthesizedExplicitImplementations(CancellationToken.None);
+            var method2ExplicitImpls = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods;
             Assert.Equal(2, method2ExplicitImpls.Length);
             foreach (var explicitImpl in method2ExplicitImpls)
             {
@@ -156,7 +156,7 @@ public override void VirtualMethod(int x) { }
             AssertNoParameterHasModOpts(classNonVirtualMethod);
 
             // no bridge methods
-            Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).Length);
+            Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length);
         }
 
         /// <summary>
@@ -205,7 +205,7 @@ public override void NonVirtualMethod(int x) { }
             AssertNoParameterHasModOpts(baseClassNonVirtualMethod);
 
             // no bridge methods
-            Assert.Equal(0, baseClass.GetSynthesizedExplicitImplementations(CancellationToken.None).Length);
+            Assert.Equal(0, baseClass.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length);
 
             var derivedClass = global.GetMember<SourceNamedTypeSymbol>("Derived");
 
@@ -218,7 +218,7 @@ public override void NonVirtualMethod(int x) { }
             AssertNoParameterHasModOpts(derivedClassNonVirtualMethod);
 
             // no bridge methods
-            Assert.Equal(0, derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None).Length);
+            Assert.Equal(0, derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length);
         }
 
         /// <summary>
@@ -406,7 +406,7 @@ class Class3 : CppCli.CppBase2, CppCli.CppInterface1
             var class1 = global.GetMember<SourceNamedTypeSymbol>("Class1");
 
             //both implementations are from the base class
-            var class1SynthesizedExplicitImpls = class1.GetSynthesizedExplicitImplementations(CancellationToken.None);
+            var class1SynthesizedExplicitImpls = class1.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods;
             Assert.Equal(1, class1SynthesizedExplicitImpls.Length); //Don't need a bridge method for the virtual base method.
             foreach (var explicitImpl in class1SynthesizedExplicitImpls)
             {
@@ -421,7 +421,7 @@ class Class3 : CppCli.CppBase2, CppCli.CppInterface1
             AssertAllParametersHaveConstModOpt(class2Method1);
 
             //Method2 is implemented in the base class
-            var class2Method2SynthesizedExplicitImpl = class2.GetSynthesizedExplicitImplementations(CancellationToken.None).Single();
+            var class2Method2SynthesizedExplicitImpl = class2.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single();
             Assert.Equal("Method2", class2Method2SynthesizedExplicitImpl.ExplicitInterfaceImplementations.Single().Name);
             Assert.Same(baseClass, class2Method2SynthesizedExplicitImpl.ImplementingMethod.ContainingType);
             AssertAllParametersHaveConstModOpt(class2Method2SynthesizedExplicitImpl);
@@ -434,7 +434,7 @@ class Class3 : CppCli.CppBase2, CppCli.CppInterface1
 
             // GetSynthesizedExplicitImplementations doesn't guarantee order, so sort to make the asserts easier to write.
 
-            var class3SynthesizedExplicitImpls = (from m in class3.GetSynthesizedExplicitImplementations(CancellationToken.None) orderby m.Name select m).ToArray();
+            var class3SynthesizedExplicitImpls = (from m in class3.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods orderby m.Name select m).ToArray();
             Assert.Equal(2, class3SynthesizedExplicitImpls.Length);
 
             var class3Method1SynthesizedExplicitImpl = class3SynthesizedExplicitImpls[0];
@@ -482,7 +482,7 @@ void I2.M1(int x) { }
             }
 
             //no bridge methods
-            Assert.False(@class.GetSynthesizedExplicitImplementations(CancellationToken.None).Any());
+            Assert.False(@class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Any());
         }
 
         /// <summary>
@@ -567,7 +567,7 @@ int CppCli.CppIndexerInterface.this[int x]
             var classIndexer = (PropertySymbol)@class.GetMembers().Where(s => s.Kind == SymbolKind.Property).Single();
             AssertAllParametersHaveConstModOpt(classIndexer);
 
-            Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).Length);
+            Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length);
         }
 
         /// <summary>
@@ -601,7 +601,7 @@ public int this[int x]
             AssertNoParameterHasModOpts(classIndexer);
 
             // bridge methods for implicit implementations have custom modifiers
-            var explicitImpls = @class.GetSynthesizedExplicitImplementations(CancellationToken.None);
+            var explicitImpls = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods;
             Assert.Equal(2, explicitImpls.Length);
 
             var explicitGetterImpl = explicitImpls.Where(impl => impl.ImplementingMethod.MethodKind == MethodKind.PropertyGet).Single();
@@ -641,7 +641,7 @@ public override int this[int x]
             var classIndexer = (PropertySymbol)@class.GetMembers().Where(s => s.Kind == SymbolKind.Property).Single();
             AssertAllParametersHaveConstModOpt(classIndexer);
 
-            Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).Length);
+            Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length);
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/StaticAbstractMembersInInterfacesTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/StaticAbstractMembersInInterfacesTests.cs
new file mode 100644
index 0000000000000..e0dd8695f7fa4
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/StaticAbstractMembersInInterfacesTests.cs
@@ -0,0 +1,26743 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
+using Microsoft.CodeAnalysis.CSharp.Symbols.Retargeting;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Symbols
+{
+    public class StaticAbstractMembersInInterfacesTests : CSharpTestBase
+    {
+        [Fact]
+        public void MethodModifiers_01()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01()
+    ; 
+
+    virtual static void M02()
+    ; 
+
+    sealed static void M03() 
+    ; 
+
+    override static void M04() 
+    ; 
+
+    abstract virtual static void M05()
+    ; 
+
+    abstract sealed static void M06()
+    ; 
+
+    abstract override static void M07()
+    ; 
+
+    virtual sealed static void M08() 
+    ; 
+
+    virtual override static void M09() 
+    ; 
+
+    sealed override static void M10() 
+    ; 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static void M01()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(4, 26),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (7,25): error CS0501: 'I1.M02()' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M02").WithArguments("I1.M02()").WithLocation(7, 25),
+                // (10,24): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed static void M03() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "9.0", "preview").WithLocation(10, 24),
+                // (10,24): error CS0501: 'I1.M03()' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed static void M03() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M03").WithArguments("I1.M03()").WithLocation(10, 24),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (13,26): error CS0501: 'I1.M04()' must declare a body because it is not marked abstract, extern, or partial
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M04").WithArguments("I1.M04()").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "9.0", "preview").WithLocation(16, 34),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "9.0", "preview").WithLocation(19, 33),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "9.0", "preview").WithLocation(22, 35),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (25,32): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "9.0", "preview").WithLocation(25, 32),
+                // (25,32): error CS0501: 'I1.M08()' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M08").WithArguments("I1.M08()").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (28,34): error CS0501: 'I1.M09()' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M09").WithArguments("I1.M09()").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33),
+                // (31,33): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "9.0", "preview").WithLocation(31, 33),
+                // (31,33): error CS0501: 'I1.M10()' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M10").WithArguments("I1.M10()").WithLocation(31, 33)
+                );
+
+            ValidateMethodModifiers_01(compilation1);
+        }
+
+        private static void ValidateMethodModifiers_01(CSharpCompilation compilation1)
+        {
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>("M01");
+
+            Assert.True(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.True(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            var m02 = i1.GetMember<MethodSymbol>("M02");
+
+            Assert.False(m02.IsAbstract);
+            Assert.False(m02.IsVirtual);
+            Assert.False(m02.IsMetadataVirtual());
+            Assert.False(m02.IsSealed);
+            Assert.True(m02.IsStatic);
+            Assert.False(m02.IsExtern);
+            Assert.False(m02.IsAsync);
+            Assert.False(m02.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m02));
+
+            var m03 = i1.GetMember<MethodSymbol>("M03");
+
+            Assert.False(m03.IsAbstract);
+            Assert.False(m03.IsVirtual);
+            Assert.False(m03.IsMetadataVirtual());
+            Assert.False(m03.IsSealed);
+            Assert.True(m03.IsStatic);
+            Assert.False(m03.IsExtern);
+            Assert.False(m03.IsAsync);
+            Assert.False(m03.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m03));
+
+            var m04 = i1.GetMember<MethodSymbol>("M04");
+
+            Assert.False(m04.IsAbstract);
+            Assert.False(m04.IsVirtual);
+            Assert.False(m04.IsMetadataVirtual());
+            Assert.False(m04.IsSealed);
+            Assert.True(m04.IsStatic);
+            Assert.False(m04.IsExtern);
+            Assert.False(m04.IsAsync);
+            Assert.False(m04.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m04));
+
+            var m05 = i1.GetMember<MethodSymbol>("M05");
+
+            Assert.True(m05.IsAbstract);
+            Assert.False(m05.IsVirtual);
+            Assert.True(m05.IsMetadataVirtual());
+            Assert.False(m05.IsSealed);
+            Assert.True(m05.IsStatic);
+            Assert.False(m05.IsExtern);
+            Assert.False(m05.IsAsync);
+            Assert.False(m05.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m05));
+
+            var m06 = i1.GetMember<MethodSymbol>("M06");
+
+            Assert.True(m06.IsAbstract);
+            Assert.False(m06.IsVirtual);
+            Assert.True(m06.IsMetadataVirtual());
+            Assert.False(m06.IsSealed);
+            Assert.True(m06.IsStatic);
+            Assert.False(m06.IsExtern);
+            Assert.False(m06.IsAsync);
+            Assert.False(m06.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m06));
+
+            var m07 = i1.GetMember<MethodSymbol>("M07");
+
+            Assert.True(m07.IsAbstract);
+            Assert.False(m07.IsVirtual);
+            Assert.True(m07.IsMetadataVirtual());
+            Assert.False(m07.IsSealed);
+            Assert.True(m07.IsStatic);
+            Assert.False(m07.IsExtern);
+            Assert.False(m07.IsAsync);
+            Assert.False(m07.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m07));
+
+            var m08 = i1.GetMember<MethodSymbol>("M08");
+
+            Assert.False(m08.IsAbstract);
+            Assert.False(m08.IsVirtual);
+            Assert.False(m08.IsMetadataVirtual());
+            Assert.False(m08.IsSealed);
+            Assert.True(m08.IsStatic);
+            Assert.False(m08.IsExtern);
+            Assert.False(m08.IsAsync);
+            Assert.False(m08.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m08));
+
+            var m09 = i1.GetMember<MethodSymbol>("M09");
+
+            Assert.False(m09.IsAbstract);
+            Assert.False(m09.IsVirtual);
+            Assert.False(m09.IsMetadataVirtual());
+            Assert.False(m09.IsSealed);
+            Assert.True(m09.IsStatic);
+            Assert.False(m09.IsExtern);
+            Assert.False(m09.IsAsync);
+            Assert.False(m09.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m09));
+
+            var m10 = i1.GetMember<MethodSymbol>("M10");
+
+            Assert.False(m10.IsAbstract);
+            Assert.False(m10.IsVirtual);
+            Assert.False(m10.IsMetadataVirtual());
+            Assert.False(m10.IsSealed);
+            Assert.True(m10.IsStatic);
+            Assert.False(m10.IsExtern);
+            Assert.False(m10.IsAsync);
+            Assert.False(m10.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m10));
+        }
+
+        [Fact]
+        public void MethodModifiers_02()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01()
+    {}
+
+    virtual static void M02()
+    {}
+
+    sealed static void M03() 
+    {}
+
+    override static void M04() 
+    {}
+
+    abstract virtual static void M05()
+    {}
+
+    abstract sealed static void M06()
+    {}
+
+    abstract override static void M07()
+    {}
+
+    virtual sealed static void M08() 
+    {}
+
+    virtual override static void M09() 
+    {}
+
+    sealed override static void M10() 
+    {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static void M01()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(4, 26),
+                // (4,26): error CS0500: 'I1.M01()' cannot declare a body because it is marked abstract
+                //     abstract static void M01()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M01").WithArguments("I1.M01()").WithLocation(4, 26),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (10,24): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed static void M03() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "9.0", "preview").WithLocation(10, 24),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "9.0", "preview").WithLocation(16, 34),
+                // (16,34): error CS0500: 'I1.M05()' cannot declare a body because it is marked abstract
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M05").WithArguments("I1.M05()").WithLocation(16, 34),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "9.0", "preview").WithLocation(19, 33),
+                // (19,33): error CS0500: 'I1.M06()' cannot declare a body because it is marked abstract
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M06").WithArguments("I1.M06()").WithLocation(19, 33),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "9.0", "preview").WithLocation(22, 35),
+                // (22,35): error CS0500: 'I1.M07()' cannot declare a body because it is marked abstract
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M07").WithArguments("I1.M07()").WithLocation(22, 35),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (25,32): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "9.0", "preview").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33),
+                // (31,33): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "9.0", "preview").WithLocation(31, 33)
+                );
+
+            ValidateMethodModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void MethodModifiers_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01()
+    ; 
+
+    virtual static void M02()
+    ; 
+
+    sealed static void M03() 
+    ; 
+
+    override static void M04() 
+    ; 
+
+    abstract virtual static void M05()
+    ; 
+
+    abstract sealed static void M06()
+    ; 
+
+    abstract override static void M07()
+    ; 
+
+    virtual sealed static void M08() 
+    ; 
+
+    virtual override static void M09() 
+    ; 
+
+    sealed override static void M10() 
+    ; 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (7,25): error CS0501: 'I1.M02()' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M02").WithArguments("I1.M02()").WithLocation(7, 25),
+                // (10,24): error CS0501: 'I1.M03()' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed static void M03() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M03").WithArguments("I1.M03()").WithLocation(10, 24),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (13,26): error CS0501: 'I1.M04()' must declare a body because it is not marked abstract, extern, or partial
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M04").WithArguments("I1.M04()").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (25,32): error CS0501: 'I1.M08()' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M08").WithArguments("I1.M08()").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (28,34): error CS0501: 'I1.M09()' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M09").WithArguments("I1.M09()").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33),
+                // (31,33): error CS0501: 'I1.M10()' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M10").WithArguments("I1.M10()").WithLocation(31, 33)
+                );
+
+            ValidateMethodModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void MethodModifiers_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01()
+    {}
+
+    virtual static void M02()
+    {}
+
+    sealed static void M03() 
+    {}
+
+    override static void M04() 
+    {}
+
+    abstract virtual static void M05()
+    {}
+
+    abstract sealed static void M06()
+    {}
+
+    abstract override static void M07()
+    {}
+
+    virtual sealed static void M08() 
+    {}
+
+    virtual override static void M09() 
+    {}
+
+    sealed override static void M10() 
+    {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS0500: 'I1.M01()' cannot declare a body because it is marked abstract
+                //     abstract static void M01()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M01").WithArguments("I1.M01()").WithLocation(4, 26),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,34): error CS0500: 'I1.M05()' cannot declare a body because it is marked abstract
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M05").WithArguments("I1.M05()").WithLocation(16, 34),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,33): error CS0500: 'I1.M06()' cannot declare a body because it is marked abstract
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M06").WithArguments("I1.M06()").WithLocation(19, 33),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,35): error CS0500: 'I1.M07()' cannot declare a body because it is marked abstract
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M07").WithArguments("I1.M07()").WithLocation(22, 35),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33)
+                );
+
+            ValidateMethodModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void MethodModifiers_05()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01()
+    ; 
+
+    virtual static void M02()
+    ; 
+
+    sealed static void M03() 
+    ; 
+
+    override static void M04() 
+    ; 
+
+    abstract virtual static void M05()
+    ; 
+
+    abstract sealed static void M06()
+    ; 
+
+    abstract override static void M07()
+    ; 
+
+    virtual sealed static void M08() 
+    ; 
+
+    virtual override static void M09() 
+    ; 
+
+    sealed override static void M10() 
+    ; 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static void M01()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "7.3", "preview").WithLocation(4, 26),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (7,25): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M02").WithArguments("static", "7.3", "8.0").WithLocation(7, 25),
+                // (7,25): error CS0501: 'I1.M02()' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M02").WithArguments("I1.M02()").WithLocation(7, 25),
+                // (10,24): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed static void M03() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "7.3", "preview").WithLocation(10, 24),
+                // (10,24): error CS0501: 'I1.M03()' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed static void M03() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M03").WithArguments("I1.M03()").WithLocation(10, 24),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (13,26): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M04").WithArguments("static", "7.3", "8.0").WithLocation(13, 26),
+                // (13,26): error CS0501: 'I1.M04()' must declare a body because it is not marked abstract, extern, or partial
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M04").WithArguments("I1.M04()").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "7.3", "preview").WithLocation(16, 34),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "7.3", "preview").WithLocation(19, 33),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "7.3", "preview").WithLocation(22, 35),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (25,32): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "7.3", "preview").WithLocation(25, 32),
+                // (25,32): error CS0501: 'I1.M08()' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M08").WithArguments("I1.M08()").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (28,34): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M09").WithArguments("static", "7.3", "8.0").WithLocation(28, 34),
+                // (28,34): error CS0501: 'I1.M09()' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M09").WithArguments("I1.M09()").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33),
+                // (31,33): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "7.3", "preview").WithLocation(31, 33),
+                // (31,33): error CS0501: 'I1.M10()' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "M10").WithArguments("I1.M10()").WithLocation(31, 33)
+                );
+
+            ValidateMethodModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void MethodModifiers_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01()
+    {}
+
+    virtual static void M02()
+    {}
+
+    sealed static void M03() 
+    {}
+
+    override static void M04() 
+    {}
+
+    abstract virtual static void M05()
+    {}
+
+    abstract sealed static void M06()
+    {}
+
+    abstract override static void M07()
+    {}
+
+    virtual sealed static void M08() 
+    {}
+
+    virtual override static void M09() 
+    {}
+
+    sealed override static void M10() 
+    {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static void M01()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "7.3", "preview").WithLocation(4, 26),
+                // (4,26): error CS0500: 'I1.M01()' cannot declare a body because it is marked abstract
+                //     abstract static void M01()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M01").WithArguments("I1.M01()").WithLocation(4, 26),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (7,25): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual static void M02()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "M02").WithArguments("default interface implementation", "8.0").WithLocation(7, 25),
+                // (10,24): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed static void M03() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "7.3", "preview").WithLocation(10, 24),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (13,26): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     override static void M04() 
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "M04").WithArguments("default interface implementation", "8.0").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "7.3", "preview").WithLocation(16, 34),
+                // (16,34): error CS0500: 'I1.M05()' cannot declare a body because it is marked abstract
+                //     abstract virtual static void M05()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M05").WithArguments("I1.M05()").WithLocation(16, 34),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "7.3", "preview").WithLocation(19, 33),
+                // (19,33): error CS0500: 'I1.M06()' cannot declare a body because it is marked abstract
+                //     abstract sealed static void M06()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M06").WithArguments("I1.M06()").WithLocation(19, 33),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "7.3", "preview").WithLocation(22, 35),
+                // (22,35): error CS0500: 'I1.M07()' cannot declare a body because it is marked abstract
+                //     abstract override static void M07()
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M07").WithArguments("I1.M07()").WithLocation(22, 35),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (25,32): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     virtual sealed static void M08() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "7.3", "preview").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (28,34): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual override static void M09() 
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "M09").WithArguments("default interface implementation", "8.0").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33),
+                // (31,33): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed override static void M10() 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "7.3", "preview").WithLocation(31, 33)
+                );
+
+            ValidateMethodModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void SealedStaticConstructor_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    sealed static I1() {}
+}
+
+partial interface I2
+{
+    partial sealed static I2();
+}
+
+partial interface I2
+{
+    partial static I2() {}
+}
+
+partial interface I3
+{
+    partial static I3();
+}
+
+partial interface I3
+{
+    partial sealed static I3() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,19): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static I1() {}
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I1").WithArguments("sealed").WithLocation(4, 19),
+                // (9,5): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     partial sealed static I2();
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(9, 5),
+                // (9,5): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     partial sealed static I2();
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(9, 5),
+                // (9,27): error CS0106: The modifier 'sealed' is not valid for this item
+                //     partial sealed static I2();
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I2").WithArguments("sealed").WithLocation(9, 27),
+                // (14,5): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     partial static I2() {}
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(14, 5),
+                // (14,5): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     partial static I2() {}
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(14, 5),
+                // (14,20): error CS0111: Type 'I2' already defines a member called 'I2' with the same parameter types
+                //     partial static I2() {}
+                Diagnostic(ErrorCode.ERR_MemberAlreadyExists, "I2").WithArguments("I2", "I2").WithLocation(14, 20),
+                // (19,5): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     partial static I3();
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(19, 5),
+                // (19,5): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     partial static I3();
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(19, 5),
+                // (24,5): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     partial sealed static I3() {}
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(24, 5),
+                // (24,5): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     partial sealed static I3() {}
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(24, 5),
+                // (24,27): error CS0106: The modifier 'sealed' is not valid for this item
+                //     partial sealed static I3() {}
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I3").WithArguments("sealed").WithLocation(24, 27),
+                // (24,27): error CS0111: Type 'I3' already defines a member called 'I3' with the same parameter types
+                //     partial sealed static I3() {}
+                Diagnostic(ErrorCode.ERR_MemberAlreadyExists, "I3").WithArguments("I3", "I3").WithLocation(24, 27)
+                );
+
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>(".cctor");
+
+            Assert.False(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.False(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+        }
+
+        [Fact]
+        public void SealedStaticConstructor_02()
+        {
+            var source1 =
+@"
+partial interface I2
+{
+    sealed static partial I2();
+}
+
+partial interface I2
+{
+    static partial I2() {}
+}
+
+partial interface I3
+{
+    static partial I3();
+}
+
+partial interface I3
+{
+    sealed static partial I3() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,19): error CS0246: The type or namespace name 'partial' could not be found (are you missing a using directive or an assembly reference?)
+                //     sealed static partial I2();
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "partial").WithArguments("partial").WithLocation(4, 19),
+                // (4,27): error CS0501: 'I2.I2()' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed static partial I2();
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "I2").WithArguments("I2.I2()").WithLocation(4, 27),
+                // (4,27): error CS0542: 'I2': member names cannot be the same as their enclosing type
+                //     sealed static partial I2();
+                Diagnostic(ErrorCode.ERR_MemberNameSameAsType, "I2").WithArguments("I2").WithLocation(4, 27),
+                // (9,12): error CS0246: The type or namespace name 'partial' could not be found (are you missing a using directive or an assembly reference?)
+                //     static partial I2() {}
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "partial").WithArguments("partial").WithLocation(9, 12),
+                // (9,20): error CS0542: 'I2': member names cannot be the same as their enclosing type
+                //     static partial I2() {}
+                Diagnostic(ErrorCode.ERR_MemberNameSameAsType, "I2").WithArguments("I2").WithLocation(9, 20),
+                // (9,20): error CS0111: Type 'I2' already defines a member called 'I2' with the same parameter types
+                //     static partial I2() {}
+                Diagnostic(ErrorCode.ERR_MemberAlreadyExists, "I2").WithArguments("I2", "I2").WithLocation(9, 20),
+                // (9,20): error CS0161: 'I2.I2()': not all code paths return a value
+                //     static partial I2() {}
+                Diagnostic(ErrorCode.ERR_ReturnExpected, "I2").WithArguments("I2.I2()").WithLocation(9, 20),
+                // (14,12): error CS0246: The type or namespace name 'partial' could not be found (are you missing a using directive or an assembly reference?)
+                //     static partial I3();
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "partial").WithArguments("partial").WithLocation(14, 12),
+                // (14,20): error CS0501: 'I3.I3()' must declare a body because it is not marked abstract, extern, or partial
+                //     static partial I3();
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "I3").WithArguments("I3.I3()").WithLocation(14, 20),
+                // (14,20): error CS0542: 'I3': member names cannot be the same as their enclosing type
+                //     static partial I3();
+                Diagnostic(ErrorCode.ERR_MemberNameSameAsType, "I3").WithArguments("I3").WithLocation(14, 20),
+                // (19,19): error CS0246: The type or namespace name 'partial' could not be found (are you missing a using directive or an assembly reference?)
+                //     sealed static partial I3() {}
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "partial").WithArguments("partial").WithLocation(19, 19),
+                // (19,27): error CS0542: 'I3': member names cannot be the same as their enclosing type
+                //     sealed static partial I3() {}
+                Diagnostic(ErrorCode.ERR_MemberNameSameAsType, "I3").WithArguments("I3").WithLocation(19, 27),
+                // (19,27): error CS0111: Type 'I3' already defines a member called 'I3' with the same parameter types
+                //     sealed static partial I3() {}
+                Diagnostic(ErrorCode.ERR_MemberAlreadyExists, "I3").WithArguments("I3", "I3").WithLocation(19, 27),
+                // (19,27): error CS0161: 'I3.I3()': not all code paths return a value
+                //     sealed static partial I3() {}
+                Diagnostic(ErrorCode.ERR_ReturnExpected, "I3").WithArguments("I3.I3()").WithLocation(19, 27)
+                );
+        }
+
+        [Fact]
+        public void AbstractStaticConstructor_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static I1();
+}
+
+interface I2
+{
+    abstract static I2() {}
+}
+
+interface I3
+{
+    static I3();
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,21): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static I1();
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I1").WithArguments("abstract").WithLocation(4, 21),
+                // (9,21): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static I2() {}
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I2").WithArguments("abstract").WithLocation(9, 21),
+                // (14,12): error CS0501: 'I3.I3()' must declare a body because it is not marked abstract, extern, or partial
+                //     static I3();
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "I3").WithArguments("I3.I3()").WithLocation(14, 12)
+                );
+
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>(".cctor");
+
+            Assert.False(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.False(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+        }
+
+        [Fact]
+        public void PartialSealedStatic_01()
+        {
+            var source1 =
+@"
+partial interface I1
+{
+    sealed static partial void M01();
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>("M01");
+
+            Assert.False(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.False(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialDefinition());
+            Assert.Null(m01.PartialImplementationPart);
+        }
+
+        [Fact]
+        public void PartialSealedStatic_02()
+        {
+            var source1 =
+@"
+partial interface I1
+{
+    sealed static partial void M01();
+}
+partial interface I1
+{
+    sealed static partial void M01() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            ValidatePartialSealedStatic_02(compilation1);
+        }
+
+        private static void ValidatePartialSealedStatic_02(CSharpCompilation compilation1)
+        {
+            compilation1.VerifyDiagnostics();
+
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>("M01");
+
+            Assert.False(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.False(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialDefinition());
+            Assert.Same(m01, m01.PartialImplementationPart.PartialDefinitionPart);
+
+            m01 = m01.PartialImplementationPart;
+
+            Assert.False(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.False(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialImplementation());
+        }
+
+        [Fact]
+        public void PartialSealedStatic_03()
+        {
+            var source1 =
+@"
+partial interface I1
+{
+    static partial void M01();
+}
+partial interface I1
+{
+    sealed static partial void M01() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            ValidatePartialSealedStatic_02(compilation1);
+        }
+
+        [Fact]
+        public void PartialSealedStatic_04()
+        {
+            var source1 =
+@"
+partial interface I1
+{
+    sealed static partial void M01();
+}
+partial interface I1
+{
+    static partial void M01() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            ValidatePartialSealedStatic_02(compilation1);
+        }
+
+        [Fact]
+        public void PartialAbstractStatic_01()
+        {
+            var source1 =
+@"
+partial interface I1
+{
+    abstract static partial void M01();
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,34): error CS0750: A partial method cannot have the 'abstract' modifier
+                //     abstract static partial void M01();
+                Diagnostic(ErrorCode.ERR_PartialMethodInvalidModifier, "M01").WithLocation(4, 34)
+                );
+
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>("M01");
+
+            Assert.True(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.True(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialDefinition());
+            Assert.Null(m01.PartialImplementationPart);
+        }
+
+        [Fact]
+        public void PartialAbstractStatic_02()
+        {
+            var source1 =
+@"
+partial interface I1
+{
+    abstract static partial void M01();
+}
+partial interface I1
+{
+    abstract static partial void M01() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,34): error CS0750: A partial method cannot have the 'abstract' modifier
+                //     abstract static partial void M01();
+                Diagnostic(ErrorCode.ERR_PartialMethodInvalidModifier, "M01").WithLocation(4, 34),
+                // (8,34): error CS0500: 'I1.M01()' cannot declare a body because it is marked abstract
+                //     abstract static partial void M01() {}
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M01").WithArguments("I1.M01()").WithLocation(8, 34),
+                // (8,34): error CS0750: A partial method cannot have the 'abstract' modifier
+                //     abstract static partial void M01() {}
+                Diagnostic(ErrorCode.ERR_PartialMethodInvalidModifier, "M01").WithLocation(8, 34)
+                );
+
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>("M01");
+
+            Assert.True(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.True(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialDefinition());
+            Assert.Same(m01, m01.PartialImplementationPart.PartialDefinitionPart);
+
+            m01 = m01.PartialImplementationPart;
+
+            Assert.True(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.True(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialImplementation());
+        }
+
+        [Fact]
+        public void PartialAbstractStatic_03()
+        {
+            var source1 =
+@"
+partial interface I1
+{
+    abstract static partial void M01();
+}
+partial interface I1
+{
+    static partial void M01() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,34): error CS0750: A partial method cannot have the 'abstract' modifier
+                //     abstract static partial void M01();
+                Diagnostic(ErrorCode.ERR_PartialMethodInvalidModifier, "M01").WithLocation(4, 34)
+                );
+
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>("M01");
+
+            Assert.True(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.True(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialDefinition());
+            Assert.Same(m01, m01.PartialImplementationPart.PartialDefinitionPart);
+
+            m01 = m01.PartialImplementationPart;
+
+            Assert.False(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.False(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialImplementation());
+        }
+
+        [Fact]
+        public void PartialAbstractStatic_04()
+        {
+            var source1 =
+@"
+partial interface I1
+{
+    static partial void M01();
+}
+partial interface I1
+{
+    abstract static partial void M01() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,34): error CS0500: 'I1.M01()' cannot declare a body because it is marked abstract
+                //     abstract static partial void M01() {}
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "M01").WithArguments("I1.M01()").WithLocation(8, 34),
+                // (8,34): error CS0750: A partial method cannot have the 'abstract' modifier
+                //     abstract static partial void M01() {}
+                Diagnostic(ErrorCode.ERR_PartialMethodInvalidModifier, "M01").WithLocation(8, 34)
+                );
+
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>("M01");
+
+            Assert.False(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.False(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialDefinition());
+            Assert.Same(m01, m01.PartialImplementationPart.PartialDefinitionPart);
+
+            m01 = m01.PartialImplementationPart;
+
+            Assert.True(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.True(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            Assert.True(m01.IsPartialImplementation());
+        }
+
+        [Fact]
+        public void PrivateAbstractStatic_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    private abstract static void M01();
+    private abstract static bool P01 { get; }
+    private abstract static event System.Action E01;
+    private abstract static I1 operator+ (I1 x);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,34): error CS0621: 'I1.M01()': virtual or abstract members cannot be private
+                //     private abstract static void M01();
+                Diagnostic(ErrorCode.ERR_VirtualPrivate, "M01").WithArguments("I1.M01()").WithLocation(4, 34),
+                // (5,34): error CS0621: 'I1.P01': virtual or abstract members cannot be private
+                //     private abstract static bool P01 { get; }
+                Diagnostic(ErrorCode.ERR_VirtualPrivate, "P01").WithArguments("I1.P01").WithLocation(5, 34),
+                // (6,49): error CS0621: 'I1.E01': virtual or abstract members cannot be private
+                //     private abstract static event System.Action E01;
+                Diagnostic(ErrorCode.ERR_VirtualPrivate, "E01").WithArguments("I1.E01").WithLocation(6, 49),
+                // (7,40): error CS0558: User-defined operator 'I1.operator +(I1)' must be declared static and public
+                //     private abstract static I1 operator+ (I1 x);
+                Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, "+").WithArguments("I1.operator +(I1)").WithLocation(7, 40)
+                );
+        }
+
+        [Fact]
+        public void PropertyModifiers_01()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool M01 { get
+    ; } 
+
+    virtual static bool M02 { get
+    ; } 
+
+    sealed static bool M03 { get
+    ; } 
+
+    override static bool M04 { get
+    ; } 
+
+    abstract virtual static bool M05 { get
+    ; } 
+
+    abstract sealed static bool M06 { get
+    ; } 
+
+    abstract override static bool M07 { get
+    ; } 
+
+    virtual sealed static bool M08 { get
+    ; } 
+
+    virtual override static bool M09 { get
+    ; } 
+
+    sealed override static bool M10 { get
+    ; } 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool M01 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(4, 26),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static bool M02 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (10,24): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed static bool M03 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "9.0", "preview").WithLocation(10, 24),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static bool M04 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "9.0", "preview").WithLocation(16, 34),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "9.0", "preview").WithLocation(19, 33),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "9.0", "preview").WithLocation(22, 35),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (25,32): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "9.0", "preview").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33),
+                // (31,33): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "9.0", "preview").WithLocation(31, 33)
+                );
+
+            ValidatePropertyModifiers_01(compilation1);
+        }
+
+        private static void ValidatePropertyModifiers_01(CSharpCompilation compilation1)
+        {
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+
+            {
+                var m01 = i1.GetMember<PropertySymbol>("M01");
+
+                Assert.True(m01.IsAbstract);
+                Assert.False(m01.IsVirtual);
+                Assert.False(m01.IsSealed);
+                Assert.True(m01.IsStatic);
+                Assert.False(m01.IsExtern);
+                Assert.False(m01.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+                var m02 = i1.GetMember<PropertySymbol>("M02");
+
+                Assert.False(m02.IsAbstract);
+                Assert.False(m02.IsVirtual);
+                Assert.False(m02.IsSealed);
+                Assert.True(m02.IsStatic);
+                Assert.False(m02.IsExtern);
+                Assert.False(m02.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m02));
+
+                var m03 = i1.GetMember<PropertySymbol>("M03");
+
+                Assert.False(m03.IsAbstract);
+                Assert.False(m03.IsVirtual);
+                Assert.False(m03.IsSealed);
+                Assert.True(m03.IsStatic);
+                Assert.False(m03.IsExtern);
+                Assert.False(m03.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m03));
+
+                var m04 = i1.GetMember<PropertySymbol>("M04");
+
+                Assert.False(m04.IsAbstract);
+                Assert.False(m04.IsVirtual);
+                Assert.False(m04.IsSealed);
+                Assert.True(m04.IsStatic);
+                Assert.False(m04.IsExtern);
+                Assert.False(m04.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m04));
+
+                var m05 = i1.GetMember<PropertySymbol>("M05");
+
+                Assert.True(m05.IsAbstract);
+                Assert.False(m05.IsVirtual);
+                Assert.False(m05.IsSealed);
+                Assert.True(m05.IsStatic);
+                Assert.False(m05.IsExtern);
+                Assert.False(m05.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m05));
+
+                var m06 = i1.GetMember<PropertySymbol>("M06");
+
+                Assert.True(m06.IsAbstract);
+                Assert.False(m06.IsVirtual);
+                Assert.False(m06.IsSealed);
+                Assert.True(m06.IsStatic);
+                Assert.False(m06.IsExtern);
+                Assert.False(m06.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m06));
+
+                var m07 = i1.GetMember<PropertySymbol>("M07");
+
+                Assert.True(m07.IsAbstract);
+                Assert.False(m07.IsVirtual);
+                Assert.False(m07.IsSealed);
+                Assert.True(m07.IsStatic);
+                Assert.False(m07.IsExtern);
+                Assert.False(m07.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m07));
+
+                var m08 = i1.GetMember<PropertySymbol>("M08");
+
+                Assert.False(m08.IsAbstract);
+                Assert.False(m08.IsVirtual);
+                Assert.False(m08.IsSealed);
+                Assert.True(m08.IsStatic);
+                Assert.False(m08.IsExtern);
+                Assert.False(m08.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m08));
+
+                var m09 = i1.GetMember<PropertySymbol>("M09");
+
+                Assert.False(m09.IsAbstract);
+                Assert.False(m09.IsVirtual);
+                Assert.False(m09.IsSealed);
+                Assert.True(m09.IsStatic);
+                Assert.False(m09.IsExtern);
+                Assert.False(m09.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m09));
+
+                var m10 = i1.GetMember<PropertySymbol>("M10");
+
+                Assert.False(m10.IsAbstract);
+                Assert.False(m10.IsVirtual);
+                Assert.False(m10.IsSealed);
+                Assert.True(m10.IsStatic);
+                Assert.False(m10.IsExtern);
+                Assert.False(m10.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m10));
+            }
+            {
+                var m01 = i1.GetMember<PropertySymbol>("M01").GetMethod;
+
+                Assert.True(m01.IsAbstract);
+                Assert.False(m01.IsVirtual);
+                Assert.True(m01.IsMetadataVirtual());
+                Assert.False(m01.IsSealed);
+                Assert.True(m01.IsStatic);
+                Assert.False(m01.IsExtern);
+                Assert.False(m01.IsAsync);
+                Assert.False(m01.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+                var m02 = i1.GetMember<PropertySymbol>("M02").GetMethod;
+
+                Assert.False(m02.IsAbstract);
+                Assert.False(m02.IsVirtual);
+                Assert.False(m02.IsMetadataVirtual());
+                Assert.False(m02.IsSealed);
+                Assert.True(m02.IsStatic);
+                Assert.False(m02.IsExtern);
+                Assert.False(m02.IsAsync);
+                Assert.False(m02.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m02));
+
+                var m03 = i1.GetMember<PropertySymbol>("M03").GetMethod;
+
+                Assert.False(m03.IsAbstract);
+                Assert.False(m03.IsVirtual);
+                Assert.False(m03.IsMetadataVirtual());
+                Assert.False(m03.IsSealed);
+                Assert.True(m03.IsStatic);
+                Assert.False(m03.IsExtern);
+                Assert.False(m03.IsAsync);
+                Assert.False(m03.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m03));
+
+                var m04 = i1.GetMember<PropertySymbol>("M04").GetMethod;
+
+                Assert.False(m04.IsAbstract);
+                Assert.False(m04.IsVirtual);
+                Assert.False(m04.IsMetadataVirtual());
+                Assert.False(m04.IsSealed);
+                Assert.True(m04.IsStatic);
+                Assert.False(m04.IsExtern);
+                Assert.False(m04.IsAsync);
+                Assert.False(m04.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m04));
+
+                var m05 = i1.GetMember<PropertySymbol>("M05").GetMethod;
+
+                Assert.True(m05.IsAbstract);
+                Assert.False(m05.IsVirtual);
+                Assert.True(m05.IsMetadataVirtual());
+                Assert.False(m05.IsSealed);
+                Assert.True(m05.IsStatic);
+                Assert.False(m05.IsExtern);
+                Assert.False(m05.IsAsync);
+                Assert.False(m05.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m05));
+
+                var m06 = i1.GetMember<PropertySymbol>("M06").GetMethod;
+
+                Assert.True(m06.IsAbstract);
+                Assert.False(m06.IsVirtual);
+                Assert.True(m06.IsMetadataVirtual());
+                Assert.False(m06.IsSealed);
+                Assert.True(m06.IsStatic);
+                Assert.False(m06.IsExtern);
+                Assert.False(m06.IsAsync);
+                Assert.False(m06.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m06));
+
+                var m07 = i1.GetMember<PropertySymbol>("M07").GetMethod;
+
+                Assert.True(m07.IsAbstract);
+                Assert.False(m07.IsVirtual);
+                Assert.True(m07.IsMetadataVirtual());
+                Assert.False(m07.IsSealed);
+                Assert.True(m07.IsStatic);
+                Assert.False(m07.IsExtern);
+                Assert.False(m07.IsAsync);
+                Assert.False(m07.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m07));
+
+                var m08 = i1.GetMember<PropertySymbol>("M08").GetMethod;
+
+                Assert.False(m08.IsAbstract);
+                Assert.False(m08.IsVirtual);
+                Assert.False(m08.IsMetadataVirtual());
+                Assert.False(m08.IsSealed);
+                Assert.True(m08.IsStatic);
+                Assert.False(m08.IsExtern);
+                Assert.False(m08.IsAsync);
+                Assert.False(m08.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m08));
+
+                var m09 = i1.GetMember<PropertySymbol>("M09").GetMethod;
+
+                Assert.False(m09.IsAbstract);
+                Assert.False(m09.IsVirtual);
+                Assert.False(m09.IsMetadataVirtual());
+                Assert.False(m09.IsSealed);
+                Assert.True(m09.IsStatic);
+                Assert.False(m09.IsExtern);
+                Assert.False(m09.IsAsync);
+                Assert.False(m09.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m09));
+
+                var m10 = i1.GetMember<PropertySymbol>("M10").GetMethod;
+
+                Assert.False(m10.IsAbstract);
+                Assert.False(m10.IsVirtual);
+                Assert.False(m10.IsMetadataVirtual());
+                Assert.False(m10.IsSealed);
+                Assert.True(m10.IsStatic);
+                Assert.False(m10.IsExtern);
+                Assert.False(m10.IsAsync);
+                Assert.False(m10.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m10));
+            }
+        }
+
+        [Fact]
+        public void PropertyModifiers_02()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool M01 { get
+    => throw null; } 
+
+    virtual static bool M02 { get
+    => throw null; } 
+
+    sealed static bool M03 { get
+    => throw null; } 
+
+    override static bool M04 { get
+    => throw null; } 
+
+    abstract virtual static bool M05 { get
+    { throw null; } } 
+
+    abstract sealed static bool M06 { get
+    => throw null; } 
+
+    abstract override static bool M07 { get
+    => throw null; } 
+
+    virtual sealed static bool M08 { get
+    => throw null; } 
+
+    virtual override static bool M09 { get
+    => throw null; } 
+
+    sealed override static bool M10 { get
+    => throw null; } 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool M01 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(4, 26),
+                // (4,32): error CS0500: 'I1.M01.get' cannot declare a body because it is marked abstract
+                //     abstract static bool M01 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M01.get").WithLocation(4, 32),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static bool M02 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (10,24): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed static bool M03 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "9.0", "preview").WithLocation(10, 24),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static bool M04 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "9.0", "preview").WithLocation(16, 34),
+                // (16,40): error CS0500: 'I1.M05.get' cannot declare a body because it is marked abstract
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M05.get").WithLocation(16, 40),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "9.0", "preview").WithLocation(19, 33),
+                // (19,39): error CS0500: 'I1.M06.get' cannot declare a body because it is marked abstract
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M06.get").WithLocation(19, 39),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "9.0", "preview").WithLocation(22, 35),
+                // (22,41): error CS0500: 'I1.M07.get' cannot declare a body because it is marked abstract
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M07.get").WithLocation(22, 41),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (25,32): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "9.0", "preview").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33),
+                // (31,33): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "9.0", "preview").WithLocation(31, 33)
+                );
+
+            ValidatePropertyModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void PropertyModifiers_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool M01 { get
+    ; } 
+
+    virtual static bool M02 { get
+    ; } 
+
+    sealed static bool M03 { get
+    ; } 
+
+    override static bool M04 { get
+    ; } 
+
+    abstract virtual static bool M05 { get
+    ; } 
+
+    abstract sealed static bool M06 { get
+    ; } 
+
+    abstract override static bool M07 { get
+    ; } 
+
+    virtual sealed static bool M08 { get
+    ; } 
+
+    virtual override static bool M09 { get
+    ; } 
+
+    sealed override static bool M10 { get
+    ; } 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static bool M02 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static bool M04 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33)
+                );
+
+            ValidatePropertyModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void PropertyModifiers_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool M01 { get
+    => throw null; } 
+
+    virtual static bool M02 { get
+    => throw null; } 
+
+    sealed static bool M03 { get
+    => throw null; } 
+
+    override static bool M04 { get
+    => throw null; } 
+
+    abstract virtual static bool M05 { get
+    { throw null; } } 
+
+    abstract sealed static bool M06 { get
+    => throw null; } 
+
+    abstract override static bool M07 { get
+    => throw null; } 
+
+    virtual sealed static bool M08 { get
+    => throw null; } 
+
+    virtual override static bool M09 { get
+    => throw null; } 
+
+    sealed override static bool M10 { get
+    => throw null; } 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,32): error CS0500: 'I1.M01.get' cannot declare a body because it is marked abstract
+                //     abstract static bool M01 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M01.get").WithLocation(4, 32),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static bool M02 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static bool M04 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,40): error CS0500: 'I1.M05.get' cannot declare a body because it is marked abstract
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M05.get").WithLocation(16, 40),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,39): error CS0500: 'I1.M06.get' cannot declare a body because it is marked abstract
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M06.get").WithLocation(19, 39),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,41): error CS0500: 'I1.M07.get' cannot declare a body because it is marked abstract
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M07.get").WithLocation(22, 41),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33)
+                );
+
+            ValidatePropertyModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void PropertyModifiers_05()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool M01 { get
+    ; } 
+
+    virtual static bool M02 { get
+    ; } 
+
+    sealed static bool M03 { get
+    ; } 
+
+    override static bool M04 { get
+    ; } 
+
+    abstract virtual static bool M05 { get
+    ; } 
+
+    abstract sealed static bool M06 { get
+    ; } 
+
+    abstract override static bool M07 { get
+    ; } 
+
+    virtual sealed static bool M08 { get
+    ; } 
+
+    virtual override static bool M09 { get
+    ; } 
+
+    sealed override static bool M10 { get
+    ; } 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static bool M01 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "7.3", "preview").WithLocation(4, 26),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static bool M02 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (7,25): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
+                //     virtual static bool M02 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M02").WithArguments("static", "7.3", "8.0").WithLocation(7, 25),
+                // (10,24): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed static bool M03 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "7.3", "preview").WithLocation(10, 24),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static bool M04 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (13,26): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
+                //     override static bool M04 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M04").WithArguments("static", "7.3", "8.0").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "7.3", "preview").WithLocation(16, 34),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "7.3", "preview").WithLocation(19, 33),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "7.3", "preview").WithLocation(22, 35),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (25,32): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "7.3", "preview").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (28,34): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M09").WithArguments("static", "7.3", "8.0").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33),
+                // (31,33): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "7.3", "preview").WithLocation(31, 33)
+                );
+
+            ValidatePropertyModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void PropertyModifiers_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool M01 { get
+    => throw null; } 
+
+    virtual static bool M02 { get
+    => throw null; } 
+
+    sealed static bool M03 { get
+    => throw null; } 
+
+    override static bool M04 { get
+    => throw null; } 
+
+    abstract virtual static bool M05 { get
+    { throw null; } } 
+
+    abstract sealed static bool M06 { get
+    => throw null; } 
+
+    abstract override static bool M07 { get
+    => throw null; } 
+
+    virtual sealed static bool M08 { get
+    => throw null; } 
+
+    virtual override static bool M09 { get
+    => throw null; } 
+
+    sealed override static bool M10 { get
+    => throw null; } 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static bool M01 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "7.3", "preview").WithLocation(4, 26),
+                // (4,32): error CS0500: 'I1.M01.get' cannot declare a body because it is marked abstract
+                //     abstract static bool M01 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M01.get").WithLocation(4, 32),
+                // (7,25): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static bool M02 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 25),
+                // (7,25): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual static bool M02 { get
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "M02").WithArguments("default interface implementation", "8.0").WithLocation(7, 25),
+                // (10,24): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed static bool M03 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "7.3", "preview").WithLocation(10, 24),
+                // (13,26): error CS0106: The modifier 'override' is not valid for this item
+                //     override static bool M04 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 26),
+                // (13,26): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     override static bool M04 { get
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "M04").WithArguments("default interface implementation", "8.0").WithLocation(13, 26),
+                // (16,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 34),
+                // (16,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "7.3", "preview").WithLocation(16, 34),
+                // (16,40): error CS0500: 'I1.M05.get' cannot declare a body because it is marked abstract
+                //     abstract virtual static bool M05 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M05.get").WithLocation(16, 40),
+                // (19,33): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 33),
+                // (19,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "7.3", "preview").WithLocation(19, 33),
+                // (19,39): error CS0500: 'I1.M06.get' cannot declare a body because it is marked abstract
+                //     abstract sealed static bool M06 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M06.get").WithLocation(19, 39),
+                // (22,35): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 35),
+                // (22,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "7.3", "preview").WithLocation(22, 35),
+                // (22,41): error CS0500: 'I1.M07.get' cannot declare a body because it is marked abstract
+                //     abstract override static bool M07 { get
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("I1.M07.get").WithLocation(22, 41),
+                // (25,32): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 32),
+                // (25,32): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     virtual sealed static bool M08 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "7.3", "preview").WithLocation(25, 32),
+                // (28,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 34),
+                // (28,34): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 34),
+                // (28,34): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual override static bool M09 { get
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "M09").WithArguments("default interface implementation", "8.0").WithLocation(28, 34),
+                // (31,33): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 33),
+                // (31,33): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed override static bool M10 { get
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "7.3", "preview").WithLocation(31, 33)
+                );
+
+            ValidatePropertyModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void EventModifiers_01()
+        {
+            var source1 =
+@"#pragma warning disable CS0067 // The event is never used
+public interface I1
+{
+    abstract static event D M01
+    ;
+
+    virtual static event D M02
+    ;
+
+    sealed static event D M03
+    ;
+
+    override static event D M04
+    ;
+
+    abstract virtual static event D M05
+    ;
+
+    abstract sealed static event D M06
+    ;
+
+    abstract override static event D M07
+    ;
+
+    virtual sealed static event D M08
+    ;
+
+    virtual override static event D M09
+    ;
+
+    sealed override static event D M10
+    ;
+}
+
+public delegate void D();
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,29): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static event D M01
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(4, 29),
+                // (7,28): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static event D M02
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 28),
+                // (10,27): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed static event D M03
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "9.0", "preview").WithLocation(10, 27),
+                // (13,29): error CS0106: The modifier 'override' is not valid for this item
+                //     override static event D M04
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 29),
+                // (16,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static event D M05
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 37),
+                // (16,37): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract virtual static event D M05
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "9.0", "preview").WithLocation(16, 37),
+                // (19,36): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static event D M06
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 36),
+                // (19,36): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static event D M06
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "9.0", "preview").WithLocation(19, 36),
+                // (22,38): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static event D M07
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 38),
+                // (22,38): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract override static event D M07
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "9.0", "preview").WithLocation(22, 38),
+                // (25,35): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static event D M08
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 35),
+                // (25,35): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     virtual sealed static event D M08
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "9.0", "preview").WithLocation(25, 35),
+                // (28,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static event D M09
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 37),
+                // (28,37): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static event D M09
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 37),
+                // (31,36): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static event D M10
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 36),
+                // (31,36): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed override static event D M10
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "9.0", "preview").WithLocation(31, 36)
+                );
+
+            ValidateEventModifiers_01(compilation1);
+        }
+
+        private static void ValidateEventModifiers_01(CSharpCompilation compilation1)
+        {
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+
+            {
+                var m01 = i1.GetMember<EventSymbol>("M01");
+
+                Assert.True(m01.IsAbstract);
+                Assert.False(m01.IsVirtual);
+                Assert.False(m01.IsSealed);
+                Assert.True(m01.IsStatic);
+                Assert.False(m01.IsExtern);
+                Assert.False(m01.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+                var m02 = i1.GetMember<EventSymbol>("M02");
+
+                Assert.False(m02.IsAbstract);
+                Assert.False(m02.IsVirtual);
+                Assert.False(m02.IsSealed);
+                Assert.True(m02.IsStatic);
+                Assert.False(m02.IsExtern);
+                Assert.False(m02.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m02));
+
+                var m03 = i1.GetMember<EventSymbol>("M03");
+
+                Assert.False(m03.IsAbstract);
+                Assert.False(m03.IsVirtual);
+                Assert.False(m03.IsSealed);
+                Assert.True(m03.IsStatic);
+                Assert.False(m03.IsExtern);
+                Assert.False(m03.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m03));
+
+                var m04 = i1.GetMember<EventSymbol>("M04");
+
+                Assert.False(m04.IsAbstract);
+                Assert.False(m04.IsVirtual);
+                Assert.False(m04.IsSealed);
+                Assert.True(m04.IsStatic);
+                Assert.False(m04.IsExtern);
+                Assert.False(m04.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m04));
+
+                var m05 = i1.GetMember<EventSymbol>("M05");
+
+                Assert.True(m05.IsAbstract);
+                Assert.False(m05.IsVirtual);
+                Assert.False(m05.IsSealed);
+                Assert.True(m05.IsStatic);
+                Assert.False(m05.IsExtern);
+                Assert.False(m05.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m05));
+
+                var m06 = i1.GetMember<EventSymbol>("M06");
+
+                Assert.True(m06.IsAbstract);
+                Assert.False(m06.IsVirtual);
+                Assert.False(m06.IsSealed);
+                Assert.True(m06.IsStatic);
+                Assert.False(m06.IsExtern);
+                Assert.False(m06.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m06));
+
+                var m07 = i1.GetMember<EventSymbol>("M07");
+
+                Assert.True(m07.IsAbstract);
+                Assert.False(m07.IsVirtual);
+                Assert.False(m07.IsSealed);
+                Assert.True(m07.IsStatic);
+                Assert.False(m07.IsExtern);
+                Assert.False(m07.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m07));
+
+                var m08 = i1.GetMember<EventSymbol>("M08");
+
+                Assert.False(m08.IsAbstract);
+                Assert.False(m08.IsVirtual);
+                Assert.False(m08.IsSealed);
+                Assert.True(m08.IsStatic);
+                Assert.False(m08.IsExtern);
+                Assert.False(m08.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m08));
+
+                var m09 = i1.GetMember<EventSymbol>("M09");
+
+                Assert.False(m09.IsAbstract);
+                Assert.False(m09.IsVirtual);
+                Assert.False(m09.IsSealed);
+                Assert.True(m09.IsStatic);
+                Assert.False(m09.IsExtern);
+                Assert.False(m09.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m09));
+
+                var m10 = i1.GetMember<EventSymbol>("M10");
+
+                Assert.False(m10.IsAbstract);
+                Assert.False(m10.IsVirtual);
+                Assert.False(m10.IsSealed);
+                Assert.True(m10.IsStatic);
+                Assert.False(m10.IsExtern);
+                Assert.False(m10.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m10));
+            }
+
+            foreach (var addAccessor in new[] { true, false })
+            {
+                var m01 = getAccessor(i1.GetMember<EventSymbol>("M01"), addAccessor);
+
+                Assert.True(m01.IsAbstract);
+                Assert.False(m01.IsVirtual);
+                Assert.True(m01.IsMetadataVirtual());
+                Assert.False(m01.IsSealed);
+                Assert.True(m01.IsStatic);
+                Assert.False(m01.IsExtern);
+                Assert.False(m01.IsAsync);
+                Assert.False(m01.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+                var m02 = getAccessor(i1.GetMember<EventSymbol>("M02"), addAccessor);
+
+                Assert.False(m02.IsAbstract);
+                Assert.False(m02.IsVirtual);
+                Assert.False(m02.IsMetadataVirtual());
+                Assert.False(m02.IsSealed);
+                Assert.True(m02.IsStatic);
+                Assert.False(m02.IsExtern);
+                Assert.False(m02.IsAsync);
+                Assert.False(m02.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m02));
+
+                var m03 = getAccessor(i1.GetMember<EventSymbol>("M03"), addAccessor);
+
+                Assert.False(m03.IsAbstract);
+                Assert.False(m03.IsVirtual);
+                Assert.False(m03.IsMetadataVirtual());
+                Assert.False(m03.IsSealed);
+                Assert.True(m03.IsStatic);
+                Assert.False(m03.IsExtern);
+                Assert.False(m03.IsAsync);
+                Assert.False(m03.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m03));
+
+                var m04 = getAccessor(i1.GetMember<EventSymbol>("M04"), addAccessor);
+
+                Assert.False(m04.IsAbstract);
+                Assert.False(m04.IsVirtual);
+                Assert.False(m04.IsMetadataVirtual());
+                Assert.False(m04.IsSealed);
+                Assert.True(m04.IsStatic);
+                Assert.False(m04.IsExtern);
+                Assert.False(m04.IsAsync);
+                Assert.False(m04.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m04));
+
+                var m05 = getAccessor(i1.GetMember<EventSymbol>("M05"), addAccessor);
+
+                Assert.True(m05.IsAbstract);
+                Assert.False(m05.IsVirtual);
+                Assert.True(m05.IsMetadataVirtual());
+                Assert.False(m05.IsSealed);
+                Assert.True(m05.IsStatic);
+                Assert.False(m05.IsExtern);
+                Assert.False(m05.IsAsync);
+                Assert.False(m05.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m05));
+
+                var m06 = getAccessor(i1.GetMember<EventSymbol>("M06"), addAccessor);
+
+                Assert.True(m06.IsAbstract);
+                Assert.False(m06.IsVirtual);
+                Assert.True(m06.IsMetadataVirtual());
+                Assert.False(m06.IsSealed);
+                Assert.True(m06.IsStatic);
+                Assert.False(m06.IsExtern);
+                Assert.False(m06.IsAsync);
+                Assert.False(m06.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m06));
+
+                var m07 = getAccessor(i1.GetMember<EventSymbol>("M07"), addAccessor);
+
+                Assert.True(m07.IsAbstract);
+                Assert.False(m07.IsVirtual);
+                Assert.True(m07.IsMetadataVirtual());
+                Assert.False(m07.IsSealed);
+                Assert.True(m07.IsStatic);
+                Assert.False(m07.IsExtern);
+                Assert.False(m07.IsAsync);
+                Assert.False(m07.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m07));
+
+                var m08 = getAccessor(i1.GetMember<EventSymbol>("M08"), addAccessor);
+
+                Assert.False(m08.IsAbstract);
+                Assert.False(m08.IsVirtual);
+                Assert.False(m08.IsMetadataVirtual());
+                Assert.False(m08.IsSealed);
+                Assert.True(m08.IsStatic);
+                Assert.False(m08.IsExtern);
+                Assert.False(m08.IsAsync);
+                Assert.False(m08.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m08));
+
+                var m09 = getAccessor(i1.GetMember<EventSymbol>("M09"), addAccessor);
+
+                Assert.False(m09.IsAbstract);
+                Assert.False(m09.IsVirtual);
+                Assert.False(m09.IsMetadataVirtual());
+                Assert.False(m09.IsSealed);
+                Assert.True(m09.IsStatic);
+                Assert.False(m09.IsExtern);
+                Assert.False(m09.IsAsync);
+                Assert.False(m09.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m09));
+
+                var m10 = getAccessor(i1.GetMember<EventSymbol>("M10"), addAccessor);
+
+                Assert.False(m10.IsAbstract);
+                Assert.False(m10.IsVirtual);
+                Assert.False(m10.IsMetadataVirtual());
+                Assert.False(m10.IsSealed);
+                Assert.True(m10.IsStatic);
+                Assert.False(m10.IsExtern);
+                Assert.False(m10.IsAsync);
+                Assert.False(m10.IsOverride);
+                Assert.Null(i1.FindImplementationForInterfaceMember(m10));
+            }
+
+            static MethodSymbol getAccessor(EventSymbol e, bool addAccessor)
+            {
+                return addAccessor ? e.AddMethod : e.RemoveMethod;
+            }
+        }
+
+        [Fact]
+        public void EventModifiers_02()
+        {
+            var source1 =
+@"#pragma warning disable CS0067 // The event is never used
+public interface I1
+{
+    abstract static event D M01 { add {} remove {} }
+    
+
+    virtual static event D M02 { add {} remove {} }
+    
+
+    sealed static event D M03 { add {} remove {} }
+    
+
+    override static event D M04 { add {} remove {} }
+    
+
+    abstract virtual static event D M05 { add {} remove {} }
+    
+
+    abstract sealed static event D M06 { add {} remove {} }
+    
+
+    abstract override static event D M07 { add {} remove {} }
+    
+
+    virtual sealed static event D M08 { add {} remove {} }
+    
+
+    virtual override static event D M09 { add {} remove {} }
+    
+
+    sealed override static event D M10 { add {} remove {} }
+}
+
+public delegate void D();
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,29): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static event D M01 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(4, 29),
+                // (4,33): error CS8712: 'I1.M01': abstract event cannot use event accessor syntax
+                //     abstract static event D M01 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M01").WithLocation(4, 33),
+                // (7,28): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static event D M02 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 28),
+                // (10,27): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed static event D M03 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "9.0", "preview").WithLocation(10, 27),
+                // (13,29): error CS0106: The modifier 'override' is not valid for this item
+                //     override static event D M04 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 29),
+                // (16,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static event D M05 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 37),
+                // (16,37): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract virtual static event D M05 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "9.0", "preview").WithLocation(16, 37),
+                // (16,41): error CS8712: 'I1.M05': abstract event cannot use event accessor syntax
+                //     abstract virtual static event D M05 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M05").WithLocation(16, 41),
+                // (19,36): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static event D M06 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 36),
+                // (19,36): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static event D M06 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "9.0", "preview").WithLocation(19, 36),
+                // (19,40): error CS8712: 'I1.M06': abstract event cannot use event accessor syntax
+                //     abstract sealed static event D M06 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M06").WithLocation(19, 40),
+                // (22,38): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static event D M07 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 38),
+                // (22,38): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract override static event D M07 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "9.0", "preview").WithLocation(22, 38),
+                // (22,42): error CS8712: 'I1.M07': abstract event cannot use event accessor syntax
+                //     abstract override static event D M07 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M07").WithLocation(22, 42),
+                // (25,35): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static event D M08 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 35),
+                // (25,35): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     virtual sealed static event D M08 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "9.0", "preview").WithLocation(25, 35),
+                // (28,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static event D M09 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 37),
+                // (28,37): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static event D M09 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 37),
+                // (31,36): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static event D M10 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 36),
+                // (31,36): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed override static event D M10 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "9.0", "preview").WithLocation(31, 36)
+                );
+
+            ValidateEventModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void EventModifiers_03()
+        {
+            var source1 =
+@"#pragma warning disable CS0067 // The event is never used
+public interface I1
+{
+    abstract static event D M01
+    ;
+
+    virtual static event D M02
+    ;
+
+    sealed static event D M03
+    ;
+
+    override static event D M04
+    ;
+
+    abstract virtual static event D M05
+    ;
+
+    abstract sealed static event D M06
+    ;
+
+    abstract override static event D M07
+    ;
+
+    virtual sealed static event D M08
+    ;
+
+    virtual override static event D M09
+    ;
+
+    sealed override static event D M10
+    ;
+}
+
+public delegate void D();
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (7,28): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static event D M02
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 28),
+                // (13,29): error CS0106: The modifier 'override' is not valid for this item
+                //     override static event D M04
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 29),
+                // (16,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static event D M05
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 37),
+                // (19,36): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static event D M06
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 36),
+                // (22,38): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static event D M07
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 38),
+                // (25,35): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static event D M08
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 35),
+                // (28,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static event D M09
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 37),
+                // (28,37): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static event D M09
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 37),
+                // (31,36): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static event D M10
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 36)
+                );
+
+            ValidateEventModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void EventModifiers_04()
+        {
+            var source1 =
+@"#pragma warning disable CS0067 // The event is never used
+public interface I1
+{
+    abstract static event D M01 { add {} remove {} }
+    
+
+    virtual static event D M02 { add {} remove {} }
+    
+
+    sealed static event D M03 { add {} remove {} }
+    
+
+    override static event D M04 { add {} remove {} }
+    
+
+    abstract virtual static event D M05 { add {} remove {} }
+    
+
+    abstract sealed static event D M06 { add {} remove {} }
+    
+
+    abstract override static event D M07 { add {} remove {} }
+    
+
+    virtual sealed static event D M08 { add {} remove {} }
+    
+
+    virtual override static event D M09 { add {} remove {} }
+    
+
+    sealed override static event D M10 { add {} remove {} }
+}
+
+public delegate void D();
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,33): error CS8712: 'I1.M01': abstract event cannot use event accessor syntax
+                //     abstract static event D M01 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M01").WithLocation(4, 33),
+                // (7,28): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static event D M02 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 28),
+                // (13,29): error CS0106: The modifier 'override' is not valid for this item
+                //     override static event D M04 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 29),
+                // (16,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static event D M05 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 37),
+                // (16,41): error CS8712: 'I1.M05': abstract event cannot use event accessor syntax
+                //     abstract virtual static event D M05 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M05").WithLocation(16, 41),
+                // (19,36): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static event D M06 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 36),
+                // (19,40): error CS8712: 'I1.M06': abstract event cannot use event accessor syntax
+                //     abstract sealed static event D M06 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M06").WithLocation(19, 40),
+                // (22,38): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static event D M07 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 38),
+                // (22,42): error CS8712: 'I1.M07': abstract event cannot use event accessor syntax
+                //     abstract override static event D M07 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M07").WithLocation(22, 42),
+                // (25,35): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static event D M08 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 35),
+                // (28,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static event D M09 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 37),
+                // (28,37): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static event D M09 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 37),
+                // (31,36): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static event D M10 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 36)
+                );
+
+            ValidateEventModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void EventModifiers_05()
+        {
+            var source1 =
+@"#pragma warning disable CS0067 // The event is never used
+public interface I1
+{
+    abstract static event D M01
+    ;
+
+    virtual static event D M02
+    ;
+
+    sealed static event D M03
+    ;
+
+    override static event D M04
+    ;
+
+    abstract virtual static event D M05
+    ;
+
+    abstract sealed static event D M06
+    ;
+
+    abstract override static event D M07
+    ;
+
+    virtual sealed static event D M08
+    ;
+
+    virtual override static event D M09
+    ;
+
+    sealed override static event D M10
+    ;
+}
+
+public delegate void D();
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,29): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static event D M01
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "7.3", "preview").WithLocation(4, 29),
+                // (7,28): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static event D M02
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 28),
+                // (7,28): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
+                //     virtual static event D M02
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M02").WithArguments("static", "7.3", "8.0").WithLocation(7, 28),
+                // (10,27): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed static event D M03
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "7.3", "preview").WithLocation(10, 27),
+                // (13,29): error CS0106: The modifier 'override' is not valid for this item
+                //     override static event D M04
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 29),
+                // (13,29): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
+                //     override static event D M04
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M04").WithArguments("static", "7.3", "8.0").WithLocation(13, 29),
+                // (16,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static event D M05
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 37),
+                // (16,37): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract virtual static event D M05
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "7.3", "preview").WithLocation(16, 37),
+                // (19,36): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static event D M06
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 36),
+                // (19,36): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static event D M06
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "7.3", "preview").WithLocation(19, 36),
+                // (22,38): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static event D M07
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 38),
+                // (22,38): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract override static event D M07
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "7.3", "preview").WithLocation(22, 38),
+                // (25,35): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static event D M08
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 35),
+                // (25,35): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     virtual sealed static event D M08
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "7.3", "preview").WithLocation(25, 35),
+                // (28,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static event D M09
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 37),
+                // (28,37): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static event D M09
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 37),
+                // (28,37): error CS8703: The modifier 'static' is not valid for this item in C# 7.3. Please use language version '8.0' or greater.
+                //     virtual override static event D M09
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M09").WithArguments("static", "7.3", "8.0").WithLocation(28, 37),
+                // (31,36): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static event D M10
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 36),
+                // (31,36): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed override static event D M10
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "7.3", "preview").WithLocation(31, 36)
+                );
+
+            ValidateEventModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void EventModifiers_06()
+        {
+            var source1 =
+@"#pragma warning disable CS0067 // The event is never used
+public interface I1
+{
+    abstract static event D M01 { add {} remove {} }
+    
+
+    virtual static event D M02 { add {} remove {} }
+    
+
+    sealed static event D M03 { add {} remove {} }
+    
+
+    override static event D M04 { add {} remove {} }
+    
+
+    abstract virtual static event D M05 { add {} remove {} }
+    
+
+    abstract sealed static event D M06 { add {} remove {} }
+    
+
+    abstract override static event D M07 { add {} remove {} }
+    
+
+    virtual sealed static event D M08 { add {} remove {} }
+    
+
+    virtual override static event D M09 { add {} remove {} }
+    
+
+    sealed override static event D M10 { add {} remove {} }
+}
+
+public delegate void D();
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,29): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static event D M01 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "7.3", "preview").WithLocation(4, 29),
+                // (4,33): error CS8712: 'I1.M01': abstract event cannot use event accessor syntax
+                //     abstract static event D M01 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M01").WithLocation(4, 33),
+                // (7,28): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual static event D M02 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M02").WithArguments("virtual").WithLocation(7, 28),
+                // (7,28): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual static event D M02 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "M02").WithArguments("default interface implementation", "8.0").WithLocation(7, 28),
+                // (10,27): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed static event D M03 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M03").WithArguments("sealed", "7.3", "preview").WithLocation(10, 27),
+                // (13,29): error CS0106: The modifier 'override' is not valid for this item
+                //     override static event D M04 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M04").WithArguments("override").WithLocation(13, 29),
+                // (13,29): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     override static event D M04 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "M04").WithArguments("default interface implementation", "8.0").WithLocation(13, 29),
+                // (16,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     abstract virtual static event D M05 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M05").WithArguments("virtual").WithLocation(16, 37),
+                // (16,37): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract virtual static event D M05 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M05").WithArguments("abstract", "7.3", "preview").WithLocation(16, 37),
+                // (16,41): error CS8712: 'I1.M05': abstract event cannot use event accessor syntax
+                //     abstract virtual static event D M05 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M05").WithLocation(16, 41),
+                // (19,36): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static event D M06 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M06").WithArguments("sealed").WithLocation(19, 36),
+                // (19,36): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static event D M06 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M06").WithArguments("abstract", "7.3", "preview").WithLocation(19, 36),
+                // (19,40): error CS8712: 'I1.M06': abstract event cannot use event accessor syntax
+                //     abstract sealed static event D M06 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M06").WithLocation(19, 40),
+                // (22,38): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static event D M07 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M07").WithArguments("override").WithLocation(22, 38),
+                // (22,38): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract override static event D M07 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M07").WithArguments("abstract", "7.3", "preview").WithLocation(22, 38),
+                // (22,42): error CS8712: 'I1.M07': abstract event cannot use event accessor syntax
+                //     abstract override static event D M07 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.M07").WithLocation(22, 42),
+                // (25,35): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual sealed static event D M08 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M08").WithArguments("virtual").WithLocation(25, 35),
+                // (25,35): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     virtual sealed static event D M08 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M08").WithArguments("sealed", "7.3", "preview").WithLocation(25, 35),
+                // (28,37): error CS0112: A static member cannot be marked as 'virtual'
+                //     virtual override static event D M09 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M09").WithArguments("virtual").WithLocation(28, 37),
+                // (28,37): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static event D M09 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M09").WithArguments("override").WithLocation(28, 37),
+                // (28,37): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual override static event D M09 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "M09").WithArguments("default interface implementation", "8.0").WithLocation(28, 37),
+                // (31,36): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static event D M10 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M10").WithArguments("override").WithLocation(31, 36),
+                // (31,36): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed override static event D M10 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M10").WithArguments("sealed", "7.3", "preview").WithLocation(31, 36)
+                );
+
+            ValidateEventModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void OperatorModifiers_01()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator+ (I1 x)
+    ; 
+
+    virtual static I1 operator- (I1 x)
+    ; 
+
+    sealed static I1 operator++ (I1 x)
+    ; 
+
+    override static I1 operator-- (I1 x)
+    ; 
+
+    abstract virtual static I1 operator! (I1 x)
+    ; 
+
+    abstract sealed static I1 operator~ (I1 x)
+    ; 
+
+    abstract override static I1 operator+ (I1 x, I1 y)
+    ; 
+
+    virtual sealed static I1 operator- (I1 x, I1 y)
+    ; 
+
+    virtual override static I1 operator* (I1 x, I1 y) 
+    ; 
+
+    sealed override static I1 operator/ (I1 x, I1 y)
+    ; 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,32): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static I1 operator+ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "+").WithArguments("abstract", "9.0", "preview").WithLocation(4, 32),
+                // (7,31): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(7, 31),
+                // (7,31): error CS0501: 'I1.operator -(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "-").WithArguments("I1.operator -(I1)").WithLocation(7, 31),
+                // (10,30): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed static I1 operator++ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "++").WithArguments("sealed", "9.0", "preview").WithLocation(10, 30),
+                // (10,30): error CS0501: 'I1.operator ++(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed static I1 operator++ (I1 x)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "++").WithArguments("I1.operator ++(I1)").WithLocation(10, 30),
+                // (13,32): error CS0106: The modifier 'override' is not valid for this item
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "--").WithArguments("override").WithLocation(13, 32),
+                // (13,32): error CS0501: 'I1.operator --(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "--").WithArguments("I1.operator --(I1)").WithLocation(13, 32),
+                // (16,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!").WithArguments("virtual").WithLocation(16, 40),
+                // (16,40): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "!").WithArguments("abstract", "9.0", "preview").WithLocation(16, 40),
+                // (19,39): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "~").WithArguments("sealed").WithLocation(19, 39),
+                // (19,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "~").WithArguments("abstract", "9.0", "preview").WithLocation(19, 39),
+                // (22,41): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("override").WithLocation(22, 41),
+                // (22,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "+").WithArguments("abstract", "9.0", "preview").WithLocation(22, 41),
+                // (25,38): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(25, 38),
+                // (25,38): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "-").WithArguments("sealed", "9.0", "preview").WithLocation(25, 38),
+                // (25,38): error CS0501: 'I1.operator -(I1, I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "-").WithArguments("I1.operator -(I1, I1)").WithLocation(25, 38),
+                // (28,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("virtual").WithLocation(28, 40),
+                // (28,40): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("override").WithLocation(28, 40),
+                // (28,40): error CS0501: 'I1.operator *(I1, I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "*").WithArguments("I1.operator *(I1, I1)").WithLocation(28, 40),
+                // (31,39): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "/").WithArguments("override").WithLocation(31, 39),
+                // (31,39): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "/").WithArguments("sealed", "9.0", "preview").WithLocation(31, 39),
+                // (31,39): error CS0501: 'I1.operator /(I1, I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "/").WithArguments("I1.operator /(I1, I1)").WithLocation(31, 39)
+                );
+
+            ValidateOperatorModifiers_01(compilation1);
+        }
+
+        private static void ValidateOperatorModifiers_01(CSharpCompilation compilation1)
+        {
+            var i1 = compilation1.GetTypeByMetadataName("I1");
+            var m01 = i1.GetMember<MethodSymbol>("op_UnaryPlus");
+
+            Assert.True(m01.IsAbstract);
+            Assert.False(m01.IsVirtual);
+            Assert.True(m01.IsMetadataVirtual());
+            Assert.False(m01.IsSealed);
+            Assert.True(m01.IsStatic);
+            Assert.False(m01.IsExtern);
+            Assert.False(m01.IsAsync);
+            Assert.False(m01.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            var m02 = i1.GetMember<MethodSymbol>("op_UnaryNegation");
+
+            Assert.False(m02.IsAbstract);
+            Assert.False(m02.IsVirtual);
+            Assert.False(m02.IsMetadataVirtual());
+            Assert.False(m02.IsSealed);
+            Assert.True(m02.IsStatic);
+            Assert.False(m02.IsExtern);
+            Assert.False(m02.IsAsync);
+            Assert.False(m02.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m02));
+
+            var m03 = i1.GetMember<MethodSymbol>("op_Increment");
+
+            Assert.False(m03.IsAbstract);
+            Assert.False(m03.IsVirtual);
+            Assert.False(m03.IsMetadataVirtual());
+            Assert.False(m03.IsSealed);
+            Assert.True(m03.IsStatic);
+            Assert.False(m03.IsExtern);
+            Assert.False(m03.IsAsync);
+            Assert.False(m03.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m03));
+
+            var m04 = i1.GetMember<MethodSymbol>("op_Decrement");
+
+            Assert.False(m04.IsAbstract);
+            Assert.False(m04.IsVirtual);
+            Assert.False(m04.IsMetadataVirtual());
+            Assert.False(m04.IsSealed);
+            Assert.True(m04.IsStatic);
+            Assert.False(m04.IsExtern);
+            Assert.False(m04.IsAsync);
+            Assert.False(m04.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m04));
+
+            var m05 = i1.GetMember<MethodSymbol>("op_LogicalNot");
+
+            Assert.True(m05.IsAbstract);
+            Assert.False(m05.IsVirtual);
+            Assert.True(m05.IsMetadataVirtual());
+            Assert.False(m05.IsSealed);
+            Assert.True(m05.IsStatic);
+            Assert.False(m05.IsExtern);
+            Assert.False(m05.IsAsync);
+            Assert.False(m05.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m05));
+
+            var m06 = i1.GetMember<MethodSymbol>("op_OnesComplement");
+
+            Assert.True(m06.IsAbstract);
+            Assert.False(m06.IsVirtual);
+            Assert.True(m06.IsMetadataVirtual());
+            Assert.False(m06.IsSealed);
+            Assert.True(m06.IsStatic);
+            Assert.False(m06.IsExtern);
+            Assert.False(m06.IsAsync);
+            Assert.False(m06.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m06));
+
+            var m07 = i1.GetMember<MethodSymbol>("op_Addition");
+
+            Assert.True(m07.IsAbstract);
+            Assert.False(m07.IsVirtual);
+            Assert.True(m07.IsMetadataVirtual());
+            Assert.False(m07.IsSealed);
+            Assert.True(m07.IsStatic);
+            Assert.False(m07.IsExtern);
+            Assert.False(m07.IsAsync);
+            Assert.False(m07.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m07));
+
+            var m08 = i1.GetMember<MethodSymbol>("op_Subtraction");
+
+            Assert.False(m08.IsAbstract);
+            Assert.False(m08.IsVirtual);
+            Assert.False(m08.IsMetadataVirtual());
+            Assert.False(m08.IsSealed);
+            Assert.True(m08.IsStatic);
+            Assert.False(m08.IsExtern);
+            Assert.False(m08.IsAsync);
+            Assert.False(m08.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m08));
+
+            var m09 = i1.GetMember<MethodSymbol>("op_Multiply");
+
+            Assert.False(m09.IsAbstract);
+            Assert.False(m09.IsVirtual);
+            Assert.False(m09.IsMetadataVirtual());
+            Assert.False(m09.IsSealed);
+            Assert.True(m09.IsStatic);
+            Assert.False(m09.IsExtern);
+            Assert.False(m09.IsAsync);
+            Assert.False(m09.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m09));
+
+            var m10 = i1.GetMember<MethodSymbol>("op_Division");
+
+            Assert.False(m10.IsAbstract);
+            Assert.False(m10.IsVirtual);
+            Assert.False(m10.IsMetadataVirtual());
+            Assert.False(m10.IsSealed);
+            Assert.True(m10.IsStatic);
+            Assert.False(m10.IsExtern);
+            Assert.False(m10.IsAsync);
+            Assert.False(m10.IsOverride);
+            Assert.Null(i1.FindImplementationForInterfaceMember(m10));
+        }
+
+        [Fact]
+        public void OperatorModifiers_02()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator+ (I1 x)
+    {throw null;} 
+
+    virtual static I1 operator- (I1 x)
+    {throw null;} 
+
+    sealed static I1 operator++ (I1 x)
+    {throw null;} 
+
+    override static I1 operator-- (I1 x)
+    {throw null;} 
+
+    abstract virtual static I1 operator! (I1 x)
+    {throw null;} 
+
+    abstract sealed static I1 operator~ (I1 x)
+    {throw null;} 
+
+    abstract override static I1 operator+ (I1 x, I1 y)
+    {throw null;} 
+
+    virtual sealed static I1 operator- (I1 x, I1 y)
+    {throw null;} 
+
+    virtual override static I1 operator* (I1 x, I1 y) 
+    {throw null;} 
+
+    sealed override static I1 operator/ (I1 x, I1 y)
+    {throw null;} 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,32): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static I1 operator+ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "+").WithArguments("abstract", "9.0", "preview").WithLocation(4, 32),
+                // (4,32): error CS0500: 'I1.operator +(I1)' cannot declare a body because it is marked abstract
+                //     abstract static I1 operator+ (I1 x)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "+").WithArguments("I1.operator +(I1)").WithLocation(4, 32),
+                // (7,31): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(7, 31),
+                // (10,30): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed static I1 operator++ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "++").WithArguments("sealed", "9.0", "preview").WithLocation(10, 30),
+                // (13,32): error CS0106: The modifier 'override' is not valid for this item
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "--").WithArguments("override").WithLocation(13, 32),
+                // (16,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!").WithArguments("virtual").WithLocation(16, 40),
+                // (16,40): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "!").WithArguments("abstract", "9.0", "preview").WithLocation(16, 40),
+                // (16,40): error CS0500: 'I1.operator !(I1)' cannot declare a body because it is marked abstract
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "!").WithArguments("I1.operator !(I1)").WithLocation(16, 40),
+                // (19,39): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "~").WithArguments("sealed").WithLocation(19, 39),
+                // (19,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "~").WithArguments("abstract", "9.0", "preview").WithLocation(19, 39),
+                // (19,39): error CS0500: 'I1.operator ~(I1)' cannot declare a body because it is marked abstract
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "~").WithArguments("I1.operator ~(I1)").WithLocation(19, 39),
+                // (22,41): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("override").WithLocation(22, 41),
+                // (22,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "+").WithArguments("abstract", "9.0", "preview").WithLocation(22, 41),
+                // (22,41): error CS0500: 'I1.operator +(I1, I1)' cannot declare a body because it is marked abstract
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "+").WithArguments("I1.operator +(I1, I1)").WithLocation(22, 41),
+                // (25,38): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(25, 38),
+                // (25,38): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "-").WithArguments("sealed", "9.0", "preview").WithLocation(25, 38),
+                // (28,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("virtual").WithLocation(28, 40),
+                // (28,40): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("override").WithLocation(28, 40),
+                // (31,39): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "/").WithArguments("override").WithLocation(31, 39),
+                // (31,39): error CS8703: The modifier 'sealed' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "/").WithArguments("sealed", "9.0", "preview").WithLocation(31, 39)
+                );
+
+            ValidateOperatorModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void OperatorModifiers_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator+ (I1 x)
+    ; 
+
+    virtual static I1 operator- (I1 x)
+    ; 
+
+    sealed static I1 operator++ (I1 x)
+    ; 
+
+    override static I1 operator-- (I1 x)
+    ; 
+
+    abstract virtual static I1 operator! (I1 x)
+    ; 
+
+    abstract sealed static I1 operator~ (I1 x)
+    ; 
+
+    abstract override static I1 operator+ (I1 x, I1 y)
+    ; 
+
+    virtual sealed static I1 operator- (I1 x, I1 y)
+    ; 
+
+    virtual override static I1 operator* (I1 x, I1 y) 
+    ; 
+
+    sealed override static I1 operator/ (I1 x, I1 y)
+    ; 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (7,31): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(7, 31),
+                // (7,31): error CS0501: 'I1.operator -(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "-").WithArguments("I1.operator -(I1)").WithLocation(7, 31),
+                // (10,30): error CS0501: 'I1.operator ++(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed static I1 operator++ (I1 x)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "++").WithArguments("I1.operator ++(I1)").WithLocation(10, 30),
+                // (13,32): error CS0106: The modifier 'override' is not valid for this item
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "--").WithArguments("override").WithLocation(13, 32),
+                // (13,32): error CS0501: 'I1.operator --(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "--").WithArguments("I1.operator --(I1)").WithLocation(13, 32),
+                // (16,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!").WithArguments("virtual").WithLocation(16, 40),
+                // (19,39): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "~").WithArguments("sealed").WithLocation(19, 39),
+                // (22,41): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("override").WithLocation(22, 41),
+                // (25,38): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(25, 38),
+                // (25,38): error CS0501: 'I1.operator -(I1, I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "-").WithArguments("I1.operator -(I1, I1)").WithLocation(25, 38),
+                // (28,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("virtual").WithLocation(28, 40),
+                // (28,40): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("override").WithLocation(28, 40),
+                // (28,40): error CS0501: 'I1.operator *(I1, I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "*").WithArguments("I1.operator *(I1, I1)").WithLocation(28, 40),
+                // (31,39): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "/").WithArguments("override").WithLocation(31, 39),
+                // (31,39): error CS0501: 'I1.operator /(I1, I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "/").WithArguments("I1.operator /(I1, I1)").WithLocation(31, 39)
+                );
+
+            ValidateOperatorModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void OperatorModifiers_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator+ (I1 x)
+    {throw null;} 
+
+    virtual static I1 operator- (I1 x)
+    {throw null;} 
+
+    sealed static I1 operator++ (I1 x)
+    {throw null;} 
+
+    override static I1 operator-- (I1 x)
+    {throw null;} 
+
+    abstract virtual static I1 operator! (I1 x)
+    {throw null;} 
+
+    abstract sealed static I1 operator~ (I1 x)
+    {throw null;} 
+
+    abstract override static I1 operator+ (I1 x, I1 y)
+    {throw null;} 
+
+    virtual sealed static I1 operator- (I1 x, I1 y)
+    {throw null;} 
+
+    virtual override static I1 operator* (I1 x, I1 y) 
+    {throw null;} 
+
+    sealed override static I1 operator/ (I1 x, I1 y)
+    {throw null;} 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,32): error CS0500: 'I1.operator +(I1)' cannot declare a body because it is marked abstract
+                //     abstract static I1 operator+ (I1 x)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "+").WithArguments("I1.operator +(I1)").WithLocation(4, 32),
+                // (7,31): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(7, 31),
+                // (13,32): error CS0106: The modifier 'override' is not valid for this item
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "--").WithArguments("override").WithLocation(13, 32),
+                // (16,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!").WithArguments("virtual").WithLocation(16, 40),
+                // (16,40): error CS0500: 'I1.operator !(I1)' cannot declare a body because it is marked abstract
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "!").WithArguments("I1.operator !(I1)").WithLocation(16, 40),
+                // (19,39): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "~").WithArguments("sealed").WithLocation(19, 39),
+                // (19,39): error CS0500: 'I1.operator ~(I1)' cannot declare a body because it is marked abstract
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "~").WithArguments("I1.operator ~(I1)").WithLocation(19, 39),
+                // (22,41): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("override").WithLocation(22, 41),
+                // (22,41): error CS0500: 'I1.operator +(I1, I1)' cannot declare a body because it is marked abstract
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "+").WithArguments("I1.operator +(I1, I1)").WithLocation(22, 41),
+                // (25,38): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(25, 38),
+                // (28,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("virtual").WithLocation(28, 40),
+                // (28,40): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("override").WithLocation(28, 40),
+                // (31,39): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "/").WithArguments("override").WithLocation(31, 39)
+                );
+
+            ValidateOperatorModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void OperatorModifiers_05()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator+ (I1 x)
+    ; 
+
+    virtual static I1 operator- (I1 x)
+    ; 
+
+    sealed static I1 operator++ (I1 x)
+    ; 
+
+    override static I1 operator-- (I1 x)
+    ; 
+
+    abstract virtual static I1 operator! (I1 x)
+    ; 
+
+    abstract sealed static I1 operator~ (I1 x)
+    ; 
+
+    abstract override static I1 operator+ (I1 x, I1 y)
+    ; 
+
+    virtual sealed static I1 operator- (I1 x, I1 y)
+    ; 
+
+    virtual override static I1 operator* (I1 x, I1 y) 
+    ; 
+
+    sealed override static I1 operator/ (I1 x, I1 y)
+    ; 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,32): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static I1 operator+ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "+").WithArguments("abstract", "7.3", "preview").WithLocation(4, 32),
+                // (7,31): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(7, 31),
+                // (7,31): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "-").WithArguments("default interface implementation", "8.0").WithLocation(7, 31),
+                // (7,31): error CS0501: 'I1.operator -(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "-").WithArguments("I1.operator -(I1)").WithLocation(7, 31),
+                // (10,30): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed static I1 operator++ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "++").WithArguments("sealed", "7.3", "preview").WithLocation(10, 30),
+                // (10,30): error CS0501: 'I1.operator ++(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed static I1 operator++ (I1 x)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "++").WithArguments("I1.operator ++(I1)").WithLocation(10, 30),
+                // (13,32): error CS0106: The modifier 'override' is not valid for this item
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "--").WithArguments("override").WithLocation(13, 32),
+                // (13,32): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "--").WithArguments("default interface implementation", "8.0").WithLocation(13, 32),
+                // (13,32): error CS0501: 'I1.operator --(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "--").WithArguments("I1.operator --(I1)").WithLocation(13, 32),
+                // (16,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!").WithArguments("virtual").WithLocation(16, 40),
+                // (16,40): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "!").WithArguments("abstract", "7.3", "preview").WithLocation(16, 40),
+                // (19,39): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "~").WithArguments("sealed").WithLocation(19, 39),
+                // (19,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "~").WithArguments("abstract", "7.3", "preview").WithLocation(19, 39),
+                // (22,41): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("override").WithLocation(22, 41),
+                // (22,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "+").WithArguments("abstract", "7.3", "preview").WithLocation(22, 41),
+                // (25,38): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(25, 38),
+                // (25,38): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "-").WithArguments("sealed", "7.3", "preview").WithLocation(25, 38),
+                // (25,38): error CS0501: 'I1.operator -(I1, I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "-").WithArguments("I1.operator -(I1, I1)").WithLocation(25, 38),
+                // (28,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("virtual").WithLocation(28, 40),
+                // (28,40): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("override").WithLocation(28, 40),
+                // (28,40): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "*").WithArguments("default interface implementation", "8.0").WithLocation(28, 40),
+                // (28,40): error CS0501: 'I1.operator *(I1, I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "*").WithArguments("I1.operator *(I1, I1)").WithLocation(28, 40),
+                // (31,39): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "/").WithArguments("override").WithLocation(31, 39),
+                // (31,39): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "/").WithArguments("sealed", "7.3", "preview").WithLocation(31, 39),
+                // (31,39): error CS0501: 'I1.operator /(I1, I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "/").WithArguments("I1.operator /(I1, I1)").WithLocation(31, 39)
+                );
+
+            ValidateOperatorModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void OperatorModifiers_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator+ (I1 x)
+    {throw null;} 
+
+    virtual static I1 operator- (I1 x)
+    {throw null;} 
+
+    sealed static I1 operator++ (I1 x)
+    {throw null;} 
+
+    override static I1 operator-- (I1 x)
+    {throw null;} 
+
+    abstract virtual static I1 operator! (I1 x)
+    {throw null;} 
+
+    abstract sealed static I1 operator~ (I1 x)
+    {throw null;} 
+
+    abstract override static I1 operator+ (I1 x, I1 y)
+    {throw null;} 
+
+    virtual sealed static I1 operator- (I1 x, I1 y)
+    {throw null;} 
+
+    virtual override static I1 operator* (I1 x, I1 y) 
+    {throw null;} 
+
+    sealed override static I1 operator/ (I1 x, I1 y)
+    {throw null;} 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,32): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static I1 operator+ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "+").WithArguments("abstract", "7.3", "preview").WithLocation(4, 32),
+                // (4,32): error CS0500: 'I1.operator +(I1)' cannot declare a body because it is marked abstract
+                //     abstract static I1 operator+ (I1 x)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "+").WithArguments("I1.operator +(I1)").WithLocation(4, 32),
+                // (7,31): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(7, 31),
+                // (7,31): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual static I1 operator- (I1 x)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "-").WithArguments("default interface implementation", "8.0").WithLocation(7, 31),
+                // (10,30): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed static I1 operator++ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "++").WithArguments("sealed", "7.3", "preview").WithLocation(10, 30),
+                // (13,32): error CS0106: The modifier 'override' is not valid for this item
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "--").WithArguments("override").WithLocation(13, 32),
+                // (13,32): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     override static I1 operator-- (I1 x)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "--").WithArguments("default interface implementation", "8.0").WithLocation(13, 32),
+                // (16,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!").WithArguments("virtual").WithLocation(16, 40),
+                // (16,40): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "!").WithArguments("abstract", "7.3", "preview").WithLocation(16, 40),
+                // (16,40): error CS0500: 'I1.operator !(I1)' cannot declare a body because it is marked abstract
+                //     abstract virtual static I1 operator! (I1 x)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "!").WithArguments("I1.operator !(I1)").WithLocation(16, 40),
+                // (19,39): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "~").WithArguments("sealed").WithLocation(19, 39),
+                // (19,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "~").WithArguments("abstract", "7.3", "preview").WithLocation(19, 39),
+                // (19,39): error CS0500: 'I1.operator ~(I1)' cannot declare a body because it is marked abstract
+                //     abstract sealed static I1 operator~ (I1 x)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "~").WithArguments("I1.operator ~(I1)").WithLocation(19, 39),
+                // (22,41): error CS0106: The modifier 'override' is not valid for this item
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("override").WithLocation(22, 41),
+                // (22,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "+").WithArguments("abstract", "7.3", "preview").WithLocation(22, 41),
+                // (22,41): error CS0500: 'I1.operator +(I1, I1)' cannot declare a body because it is marked abstract
+                //     abstract override static I1 operator+ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "+").WithArguments("I1.operator +(I1, I1)").WithLocation(22, 41),
+                // (25,38): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "-").WithArguments("virtual").WithLocation(25, 38),
+                // (25,38): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     virtual sealed static I1 operator- (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "-").WithArguments("sealed", "7.3", "preview").WithLocation(25, 38),
+                // (28,40): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("virtual").WithLocation(28, 40),
+                // (28,40): error CS0106: The modifier 'override' is not valid for this item
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "*").WithArguments("override").WithLocation(28, 40),
+                // (28,40): error CS8370: Feature 'default interface implementation' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //     virtual override static I1 operator* (I1 x, I1 y) 
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "*").WithArguments("default interface implementation", "8.0").WithLocation(28, 40),
+                // (31,39): error CS0106: The modifier 'override' is not valid for this item
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "/").WithArguments("override").WithLocation(31, 39),
+                // (31,39): error CS8703: The modifier 'sealed' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     sealed override static I1 operator/ (I1 x, I1 y)
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "/").WithArguments("sealed", "7.3", "preview").WithLocation(31, 39)
+                );
+
+            ValidateOperatorModifiers_01(compilation1);
+        }
+
+        [Fact]
+        public void OperatorModifiers_07()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool operator== (I1 x, I1 y); 
+
+    abstract static bool operator!= (I1 x, I1 y) {return false;} 
+}
+
+public interface I2
+{
+    sealed static bool operator== (I2 x, I2 y);
+
+    sealed static bool operator!= (I2 x, I2 y) {return false;} 
+}
+
+public interface I3
+{
+    abstract sealed static bool operator== (I3 x, I3 y);
+
+    abstract sealed static bool operator!= (I3 x, I3 y) {return false;} 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static bool operator== (I1 x, I1 y); 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "==").WithArguments("abstract", "7.3", "preview").WithLocation(4, 34),
+                // (6,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static bool operator!= (I1 x, I1 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "!=").WithArguments("abstract", "7.3", "preview").WithLocation(6, 34),
+                // (6,34): error CS0500: 'I1.operator !=(I1, I1)' cannot declare a body because it is marked abstract
+                //     abstract static bool operator!= (I1 x, I1 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "!=").WithArguments("I1.operator !=(I1, I1)").WithLocation(6, 34),
+                // (11,32): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static bool operator== (I2 x, I2 y);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "==").WithArguments("sealed").WithLocation(11, 32),
+                // (11,32): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static bool operator== (I2 x, I2 y);
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "==").WithLocation(11, 32),
+                // (13,32): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static bool operator!= (I2 x, I2 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!=").WithArguments("sealed").WithLocation(13, 32),
+                // (13,32): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static bool operator!= (I2 x, I2 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "!=").WithLocation(13, 32),
+                // (18,41): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool operator== (I3 x, I3 y);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "==").WithArguments("sealed").WithLocation(18, 41),
+                // (18,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static bool operator== (I3 x, I3 y);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "==").WithArguments("abstract", "7.3", "preview").WithLocation(18, 41),
+                // (20,41): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool operator!= (I3 x, I3 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!=").WithArguments("sealed").WithLocation(20, 41),
+                // (20,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static bool operator!= (I3 x, I3 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "!=").WithArguments("abstract", "7.3", "preview").WithLocation(20, 41),
+                // (20,41): error CS0500: 'I3.operator !=(I3, I3)' cannot declare a body because it is marked abstract
+                //     abstract sealed static bool operator!= (I3 x, I3 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "!=").WithArguments("I3.operator !=(I3, I3)").WithLocation(20, 41)
+                );
+
+            validate();
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool operator== (I1 x, I1 y); 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "==").WithArguments("abstract", "9.0", "preview").WithLocation(4, 34),
+                // (6,34): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool operator!= (I1 x, I1 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "!=").WithArguments("abstract", "9.0", "preview").WithLocation(6, 34),
+                // (6,34): error CS0500: 'I1.operator !=(I1, I1)' cannot declare a body because it is marked abstract
+                //     abstract static bool operator!= (I1 x, I1 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "!=").WithArguments("I1.operator !=(I1, I1)").WithLocation(6, 34),
+                // (11,32): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static bool operator== (I2 x, I2 y);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "==").WithArguments("sealed").WithLocation(11, 32),
+                // (11,32): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static bool operator== (I2 x, I2 y);
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "==").WithLocation(11, 32),
+                // (13,32): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static bool operator!= (I2 x, I2 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!=").WithArguments("sealed").WithLocation(13, 32),
+                // (13,32): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static bool operator!= (I2 x, I2 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "!=").WithLocation(13, 32),
+                // (18,41): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool operator== (I3 x, I3 y);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "==").WithArguments("sealed").WithLocation(18, 41),
+                // (18,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static bool operator== (I3 x, I3 y);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "==").WithArguments("abstract", "9.0", "preview").WithLocation(18, 41),
+                // (20,41): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool operator!= (I3 x, I3 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!=").WithArguments("sealed").WithLocation(20, 41),
+                // (20,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static bool operator!= (I3 x, I3 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "!=").WithArguments("abstract", "9.0", "preview").WithLocation(20, 41),
+                // (20,41): error CS0500: 'I3.operator !=(I3, I3)' cannot declare a body because it is marked abstract
+                //     abstract sealed static bool operator!= (I3 x, I3 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "!=").WithArguments("I3.operator !=(I3, I3)").WithLocation(20, 41)
+                );
+
+            validate();
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (6,34): error CS0500: 'I1.operator !=(I1, I1)' cannot declare a body because it is marked abstract
+                //     abstract static bool operator!= (I1 x, I1 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "!=").WithArguments("I1.operator !=(I1, I1)").WithLocation(6, 34),
+                // (11,32): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static bool operator== (I2 x, I2 y);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "==").WithArguments("sealed").WithLocation(11, 32),
+                // (11,32): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static bool operator== (I2 x, I2 y);
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "==").WithLocation(11, 32),
+                // (13,32): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static bool operator!= (I2 x, I2 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!=").WithArguments("sealed").WithLocation(13, 32),
+                // (13,32): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static bool operator!= (I2 x, I2 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "!=").WithLocation(13, 32),
+                // (18,41): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool operator== (I3 x, I3 y);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "==").WithArguments("sealed").WithLocation(18, 41),
+                // (20,41): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static bool operator!= (I3 x, I3 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "!=").WithArguments("sealed").WithLocation(20, 41),
+                // (20,41): error CS0500: 'I3.operator !=(I3, I3)' cannot declare a body because it is marked abstract
+                //     abstract sealed static bool operator!= (I3 x, I3 y) {return false;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "!=").WithArguments("I3.operator !=(I3, I3)").WithLocation(20, 41)
+                );
+
+            validate();
+
+            void validate()
+            {
+                foreach (MethodSymbol m01 in compilation1.GetTypeByMetadataName("I1").GetMembers())
+                {
+                    Assert.True(m01.IsAbstract);
+                    Assert.False(m01.IsVirtual);
+                    Assert.True(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsExtern);
+                    Assert.False(m01.IsAsync);
+                    Assert.False(m01.IsOverride);
+                    Assert.Null(m01.ContainingType.FindImplementationForInterfaceMember(m01));
+                }
+
+                foreach (MethodSymbol m01 in compilation1.GetTypeByMetadataName("I2").GetMembers())
+                {
+                    Assert.False(m01.IsAbstract);
+                    Assert.False(m01.IsVirtual);
+                    Assert.False(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsExtern);
+                    Assert.False(m01.IsAsync);
+                    Assert.False(m01.IsOverride);
+                    Assert.Null(m01.ContainingType.FindImplementationForInterfaceMember(m01));
+                }
+
+                foreach (MethodSymbol m01 in compilation1.GetTypeByMetadataName("I3").GetMembers())
+                {
+                    Assert.True(m01.IsAbstract);
+                    Assert.False(m01.IsVirtual);
+                    Assert.True(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsExtern);
+                    Assert.False(m01.IsAsync);
+                    Assert.False(m01.IsOverride);
+                    Assert.Null(m01.ContainingType.FindImplementationForInterfaceMember(m01));
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorModifiers_08()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static implicit operator int(I1 x); 
+
+    abstract static explicit operator I1(bool x) {return null;} 
+}
+
+public interface I2
+{
+    sealed static implicit operator int(I2 x);
+
+    sealed static explicit operator I2(bool x) {return null;} 
+}
+
+public interface I3
+{
+    abstract sealed static implicit operator int(I3 x);
+
+    abstract sealed static explicit operator I3(bool x) {return null;} 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular7_3,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static implicit operator int(I1 x); 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "int").WithArguments("abstract", "7.3", "preview").WithLocation(4, 39),
+                // (4,39): error CS0552: 'I1.implicit operator int(I1)': user-defined conversions to or from an interface are not allowed
+                //     abstract static implicit operator int(I1 x); 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I1.implicit operator int(I1)").WithLocation(4, 39),
+                // (6,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract static explicit operator I1(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "I1").WithArguments("abstract", "7.3", "preview").WithLocation(6, 39),
+                // (6,39): error CS0500: 'I1.explicit operator I1(bool)' cannot declare a body because it is marked abstract
+                //     abstract static explicit operator I1(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "I1").WithArguments("I1.explicit operator I1(bool)").WithLocation(6, 39),
+                // (6,39): error CS0552: 'I1.explicit operator I1(bool)': user-defined conversions to or from an interface are not allowed
+                //     abstract static explicit operator I1(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I1").WithArguments("I1.explicit operator I1(bool)").WithLocation(6, 39),
+                // (11,37): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static implicit operator int(I2 x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("sealed").WithLocation(11, 37),
+                // (11,37): error CS0552: 'I2.implicit operator int(I2)': user-defined conversions to or from an interface are not allowed
+                //     sealed static implicit operator int(I2 x);
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I2.implicit operator int(I2)").WithLocation(11, 37),
+                // (11,37): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static implicit operator int(I2 x);
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "int").WithLocation(11, 37),
+                // (13,37): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static explicit operator I2(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I2").WithArguments("sealed").WithLocation(13, 37),
+                // (13,37): error CS0552: 'I2.explicit operator I2(bool)': user-defined conversions to or from an interface are not allowed
+                //     sealed static explicit operator I2(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I2").WithArguments("I2.explicit operator I2(bool)").WithLocation(13, 37),
+                // (13,37): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static explicit operator I2(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "I2").WithLocation(13, 37),
+                // (18,46): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static implicit operator int(I3 x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("sealed").WithLocation(18, 46),
+                // (18,46): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static implicit operator int(I3 x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "int").WithArguments("abstract", "7.3", "preview").WithLocation(18, 46),
+                // (18,46): error CS0552: 'I3.implicit operator int(I3)': user-defined conversions to or from an interface are not allowed
+                //     abstract sealed static implicit operator int(I3 x);
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I3.implicit operator int(I3)").WithLocation(18, 46),
+                // (20,46): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I3").WithArguments("sealed").WithLocation(20, 46),
+                // (20,46): error CS8703: The modifier 'abstract' is not valid for this item in C# 7.3. Please use language version 'preview' or greater.
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "I3").WithArguments("abstract", "7.3", "preview").WithLocation(20, 46),
+                // (20,46): error CS0500: 'I3.explicit operator I3(bool)' cannot declare a body because it is marked abstract
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "I3").WithArguments("I3.explicit operator I3(bool)").WithLocation(20, 46),
+                // (20,46): error CS0552: 'I3.explicit operator I3(bool)': user-defined conversions to or from an interface are not allowed
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I3").WithArguments("I3.explicit operator I3(bool)").WithLocation(20, 46)
+                );
+
+            validate();
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                             parseOptions: TestOptions.Regular9,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static implicit operator int(I1 x); 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "int").WithArguments("abstract", "9.0", "preview").WithLocation(4, 39),
+                // (4,39): error CS0552: 'I1.implicit operator int(I1)': user-defined conversions to or from an interface are not allowed
+                //     abstract static implicit operator int(I1 x); 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I1.implicit operator int(I1)").WithLocation(4, 39),
+                // (6,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static explicit operator I1(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "I1").WithArguments("abstract", "9.0", "preview").WithLocation(6, 39),
+                // (6,39): error CS0500: 'I1.explicit operator I1(bool)' cannot declare a body because it is marked abstract
+                //     abstract static explicit operator I1(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "I1").WithArguments("I1.explicit operator I1(bool)").WithLocation(6, 39),
+                // (6,39): error CS0552: 'I1.explicit operator I1(bool)': user-defined conversions to or from an interface are not allowed
+                //     abstract static explicit operator I1(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I1").WithArguments("I1.explicit operator I1(bool)").WithLocation(6, 39),
+                // (11,37): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static implicit operator int(I2 x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("sealed").WithLocation(11, 37),
+                // (11,37): error CS0552: 'I2.implicit operator int(I2)': user-defined conversions to or from an interface are not allowed
+                //     sealed static implicit operator int(I2 x);
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I2.implicit operator int(I2)").WithLocation(11, 37),
+                // (11,37): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static implicit operator int(I2 x);
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "int").WithLocation(11, 37),
+                // (13,37): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static explicit operator I2(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I2").WithArguments("sealed").WithLocation(13, 37),
+                // (13,37): error CS0552: 'I2.explicit operator I2(bool)': user-defined conversions to or from an interface are not allowed
+                //     sealed static explicit operator I2(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I2").WithArguments("I2.explicit operator I2(bool)").WithLocation(13, 37),
+                // (13,37): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static explicit operator I2(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "I2").WithLocation(13, 37),
+                // (18,46): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static implicit operator int(I3 x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("sealed").WithLocation(18, 46),
+                // (18,46): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static implicit operator int(I3 x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "int").WithArguments("abstract", "9.0", "preview").WithLocation(18, 46),
+                // (18,46): error CS0552: 'I3.implicit operator int(I3)': user-defined conversions to or from an interface are not allowed
+                //     abstract sealed static implicit operator int(I3 x);
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I3.implicit operator int(I3)").WithLocation(18, 46),
+                // (20,46): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I3").WithArguments("sealed").WithLocation(20, 46),
+                // (20,46): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "I3").WithArguments("abstract", "9.0", "preview").WithLocation(20, 46),
+                // (20,46): error CS0500: 'I3.explicit operator I3(bool)' cannot declare a body because it is marked abstract
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "I3").WithArguments("I3.explicit operator I3(bool)").WithLocation(20, 46),
+                // (20,46): error CS0552: 'I3.explicit operator I3(bool)': user-defined conversions to or from an interface are not allowed
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I3").WithArguments("I3.explicit operator I3(bool)").WithLocation(20, 46)
+                );
+
+            validate();
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,39): error CS0552: 'I1.implicit operator int(I1)': user-defined conversions to or from an interface are not allowed
+                //     abstract static implicit operator int(I1 x); 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I1.implicit operator int(I1)").WithLocation(4, 39),
+                // (6,39): error CS0500: 'I1.explicit operator I1(bool)' cannot declare a body because it is marked abstract
+                //     abstract static explicit operator I1(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "I1").WithArguments("I1.explicit operator I1(bool)").WithLocation(6, 39),
+                // (6,39): error CS0552: 'I1.explicit operator I1(bool)': user-defined conversions to or from an interface are not allowed
+                //     abstract static explicit operator I1(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I1").WithArguments("I1.explicit operator I1(bool)").WithLocation(6, 39),
+                // (11,37): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static implicit operator int(I2 x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("sealed").WithLocation(11, 37),
+                // (11,37): error CS0552: 'I2.implicit operator int(I2)': user-defined conversions to or from an interface are not allowed
+                //     sealed static implicit operator int(I2 x);
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I2.implicit operator int(I2)").WithLocation(11, 37),
+                // (11,37): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static implicit operator int(I2 x);
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "int").WithLocation(11, 37),
+                // (13,37): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static explicit operator I2(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I2").WithArguments("sealed").WithLocation(13, 37),
+                // (13,37): error CS0552: 'I2.explicit operator I2(bool)': user-defined conversions to or from an interface are not allowed
+                //     sealed static explicit operator I2(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I2").WithArguments("I2.explicit operator I2(bool)").WithLocation(13, 37),
+                // (13,37): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     sealed static explicit operator I2(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "I2").WithLocation(13, 37),
+                // (18,46): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static implicit operator int(I3 x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("sealed").WithLocation(18, 46),
+                // (18,46): error CS0552: 'I3.implicit operator int(I3)': user-defined conversions to or from an interface are not allowed
+                //     abstract sealed static implicit operator int(I3 x);
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "int").WithArguments("I3.implicit operator int(I3)").WithLocation(18, 46),
+                // (20,46): error CS0106: The modifier 'sealed' is not valid for this item
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "I3").WithArguments("sealed").WithLocation(20, 46),
+                // (20,46): error CS0500: 'I3.explicit operator I3(bool)' cannot declare a body because it is marked abstract
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "I3").WithArguments("I3.explicit operator I3(bool)").WithLocation(20, 46),
+                // (20,46): error CS0552: 'I3.explicit operator I3(bool)': user-defined conversions to or from an interface are not allowed
+                //     abstract sealed static explicit operator I3(bool x) {return null;} 
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I3").WithArguments("I3.explicit operator I3(bool)").WithLocation(20, 46)
+                );
+
+            validate();
+
+            void validate()
+            {
+                foreach (MethodSymbol m01 in compilation1.GetTypeByMetadataName("I1").GetMembers())
+                {
+                    Assert.True(m01.IsAbstract);
+                    Assert.False(m01.IsVirtual);
+                    Assert.True(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsExtern);
+                    Assert.False(m01.IsAsync);
+                    Assert.False(m01.IsOverride);
+                    Assert.Null(m01.ContainingType.FindImplementationForInterfaceMember(m01));
+                }
+
+                foreach (MethodSymbol m01 in compilation1.GetTypeByMetadataName("I2").GetMembers())
+                {
+                    Assert.False(m01.IsAbstract);
+                    Assert.False(m01.IsVirtual);
+                    Assert.False(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsExtern);
+                    Assert.False(m01.IsAsync);
+                    Assert.False(m01.IsOverride);
+                    Assert.Null(m01.ContainingType.FindImplementationForInterfaceMember(m01));
+                }
+
+                foreach (MethodSymbol m01 in compilation1.GetTypeByMetadataName("I3").GetMembers())
+                {
+                    Assert.True(m01.IsAbstract);
+                    Assert.False(m01.IsVirtual);
+                    Assert.True(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsExtern);
+                    Assert.False(m01.IsAsync);
+                    Assert.False(m01.IsOverride);
+                    Assert.Null(m01.ContainingType.FindImplementationForInterfaceMember(m01));
+                }
+            }
+        }
+
+        [Fact]
+        public void FieldModifiers_01()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int F1; 
+    sealed static int F2; 
+    abstract int F3; 
+    sealed int F4; 
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,25): error CS0681: The modifier 'abstract' is not valid on fields. Try using a property instead.
+                //     abstract static int F1; 
+                Diagnostic(ErrorCode.ERR_AbstractField, "F1").WithLocation(4, 25),
+                // (5,23): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static int F2; 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "F2").WithArguments("sealed").WithLocation(5, 23),
+                // (6,18): error CS0681: The modifier 'abstract' is not valid on fields. Try using a property instead.
+                //     abstract int F3; 
+                Diagnostic(ErrorCode.ERR_AbstractField, "F3").WithLocation(6, 18),
+                // (6,18): error CS0525: Interfaces cannot contain instance fields
+                //     abstract int F3; 
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainFields, "F3").WithLocation(6, 18),
+                // (7,16): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed int F4; 
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "F4").WithArguments("sealed").WithLocation(7, 16),
+                // (7,16): error CS0525: Interfaces cannot contain instance fields
+                //     sealed int F4; 
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainFields, "F4").WithLocation(7, 16)
+                );
+        }
+
+        [Fact]
+        public void ExternAbstractStatic_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    extern abstract static void M01();
+    extern abstract static bool P01 { get; }
+    extern abstract static event System.Action E01;
+    extern abstract static I1 operator+ (I1 x);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,33): error CS0180: 'I1.M01()' cannot be both extern and abstract
+                //     extern abstract static void M01();
+                Diagnostic(ErrorCode.ERR_AbstractAndExtern, "M01").WithArguments("I1.M01()").WithLocation(4, 33),
+                // (5,33): error CS0180: 'I1.P01' cannot be both extern and abstract
+                //     extern abstract static bool P01 { get; }
+                Diagnostic(ErrorCode.ERR_AbstractAndExtern, "P01").WithArguments("I1.P01").WithLocation(5, 33),
+                // (6,48): error CS0180: 'I1.E01' cannot be both extern and abstract
+                //     extern abstract static event System.Action E01;
+                Diagnostic(ErrorCode.ERR_AbstractAndExtern, "E01").WithArguments("I1.E01").WithLocation(6, 48),
+                // (7,39): error CS0180: 'I1.operator +(I1)' cannot be both extern and abstract
+                //     extern abstract static I1 operator+ (I1 x);
+                Diagnostic(ErrorCode.ERR_AbstractAndExtern, "+").WithArguments("I1.operator +(I1)").WithLocation(7, 39)
+                );
+        }
+
+        [Fact]
+        public void ExternAbstractStatic_02()
+        {
+            var source1 =
+@"
+interface I1
+{
+    extern abstract static void M01() {}
+    extern abstract static bool P01 { get => false; }
+    extern abstract static event System.Action E01 { add {} remove {} }
+    extern abstract static I1 operator+ (I1 x) => null;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,33): error CS0180: 'I1.M01()' cannot be both extern and abstract
+                //     extern abstract static void M01() {}
+                Diagnostic(ErrorCode.ERR_AbstractAndExtern, "M01").WithArguments("I1.M01()").WithLocation(4, 33),
+                // (5,33): error CS0180: 'I1.P01' cannot be both extern and abstract
+                //     extern abstract static bool P01 { get => false; }
+                Diagnostic(ErrorCode.ERR_AbstractAndExtern, "P01").WithArguments("I1.P01").WithLocation(5, 33),
+                // (6,48): error CS0180: 'I1.E01' cannot be both extern and abstract
+                //     extern abstract static event System.Action E01 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractAndExtern, "E01").WithArguments("I1.E01").WithLocation(6, 48),
+                // (6,52): error CS8712: 'I1.E01': abstract event cannot use event accessor syntax
+                //     extern abstract static event System.Action E01 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_AbstractEventHasAccessors, "{").WithArguments("I1.E01").WithLocation(6, 52),
+                // (7,39): error CS0180: 'I1.operator +(I1)' cannot be both extern and abstract
+                //     extern abstract static I1 operator+ (I1 x) => null;
+                Diagnostic(ErrorCode.ERR_AbstractAndExtern, "+").WithArguments("I1.operator +(I1)").WithLocation(7, 39)
+                );
+        }
+
+        [Fact]
+        public void ExternSealedStatic_01()
+        {
+            var source1 =
+@"
+#pragma warning disable CS0626 // Method, operator, or accessor is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation.
+
+interface I1
+{
+    extern sealed static void M01();
+    extern sealed static bool P01 { get; }
+    extern sealed static event System.Action E01;
+    extern sealed static I1 operator+ (I1 x);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void AbstractStaticInClass_01()
+        {
+            var source1 =
+@"
+abstract class C1
+{
+    public abstract static void M01();
+    public abstract static bool P01 { get; }
+    public abstract static event System.Action E01;
+    public abstract static C1 operator+ (C1 x);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,33): error CS0112: A static member cannot be marked as 'abstract'
+                //     public abstract static void M01();
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M01").WithArguments("abstract").WithLocation(4, 33),
+                // (5,33): error CS0112: A static member cannot be marked as 'abstract'
+                //     public abstract static bool P01 { get; }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P01").WithArguments("abstract").WithLocation(5, 33),
+                // (6,48): error CS0112: A static member cannot be marked as 'abstract'
+                //     public abstract static event System.Action E01;
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "E01").WithArguments("abstract").WithLocation(6, 48),
+                // (7,39): error CS0106: The modifier 'abstract' is not valid for this item
+                //     public abstract static C1 operator+ (C1 x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("abstract").WithLocation(7, 39),
+                // (7,39): error CS0501: 'C1.operator +(C1)' must declare a body because it is not marked abstract, extern, or partial
+                //     public abstract static C1 operator+ (C1 x);
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "+").WithArguments("C1.operator +(C1)").WithLocation(7, 39)
+                );
+        }
+
+        [Fact]
+        public void SealedStaticInClass_01()
+        {
+            var source1 =
+@"
+class C1
+{
+    sealed static void M01() {}
+    sealed static bool P01 { get => false; }
+    sealed static event System.Action E01 { add {} remove {} }
+    public sealed static C1 operator+ (C1 x) => null;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,24): error CS0238: 'C1.M01()' cannot be sealed because it is not an override
+                //     sealed static void M01() {}
+                Diagnostic(ErrorCode.ERR_SealedNonOverride, "M01").WithArguments("C1.M01()").WithLocation(4, 24),
+                // (5,24): error CS0238: 'C1.P01' cannot be sealed because it is not an override
+                //     sealed static bool P01 { get => false; }
+                Diagnostic(ErrorCode.ERR_SealedNonOverride, "P01").WithArguments("C1.P01").WithLocation(5, 24),
+                // (6,39): error CS0238: 'C1.E01' cannot be sealed because it is not an override
+                //     sealed static event System.Action E01 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_SealedNonOverride, "E01").WithArguments("C1.E01").WithLocation(6, 39),
+                // (7,37): error CS0106: The modifier 'sealed' is not valid for this item
+                //     public sealed static C1 operator+ (C1 x) => null;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("sealed").WithLocation(7, 37)
+                );
+        }
+
+        [Fact]
+        public void AbstractStaticInStruct_01()
+        {
+            var source1 =
+@"
+struct C1
+{
+    public abstract static void M01();
+    public abstract static bool P01 { get; }
+    public abstract static event System.Action E01;
+    public abstract static C1 operator+ (C1 x);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,33): error CS0112: A static member cannot be marked as 'abstract'
+                //     public abstract static void M01();
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "M01").WithArguments("abstract").WithLocation(4, 33),
+                // (5,33): error CS0112: A static member cannot be marked as 'abstract'
+                //     public abstract static bool P01 { get; }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P01").WithArguments("abstract").WithLocation(5, 33),
+                // (6,48): error CS0112: A static member cannot be marked as 'abstract'
+                //     public abstract static event System.Action E01;
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "E01").WithArguments("abstract").WithLocation(6, 48),
+                // (7,39): error CS0106: The modifier 'abstract' is not valid for this item
+                //     public abstract static C1 operator+ (C1 x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("abstract").WithLocation(7, 39),
+                // (7,39): error CS0501: 'C1.operator +(C1)' must declare a body because it is not marked abstract, extern, or partial
+                //     public abstract static C1 operator+ (C1 x);
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "+").WithArguments("C1.operator +(C1)").WithLocation(7, 39)
+                );
+        }
+
+        [Fact]
+        public void SealedStaticInStruct_01()
+        {
+            var source1 =
+@"
+struct C1
+{
+    sealed static void M01() {}
+    sealed static bool P01 { get => false; }
+    sealed static event System.Action E01 { add {} remove {} }
+    public sealed static C1 operator+ (C1 x) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,24): error CS0238: 'C1.M01()' cannot be sealed because it is not an override
+                //     sealed static void M01() {}
+                Diagnostic(ErrorCode.ERR_SealedNonOverride, "M01").WithArguments("C1.M01()").WithLocation(4, 24),
+                // (5,24): error CS0238: 'C1.P01' cannot be sealed because it is not an override
+                //     sealed static bool P01 { get => false; }
+                Diagnostic(ErrorCode.ERR_SealedNonOverride, "P01").WithArguments("C1.P01").WithLocation(5, 24),
+                // (6,39): error CS0238: 'C1.E01' cannot be sealed because it is not an override
+                //     sealed static event System.Action E01 { add {} remove {} }
+                Diagnostic(ErrorCode.ERR_SealedNonOverride, "E01").WithArguments("C1.E01").WithLocation(6, 39),
+                // (7,37): error CS0106: The modifier 'sealed' is not valid for this item
+                //     public sealed static C1 operator+ (C1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "+").WithArguments("sealed").WithLocation(7, 37)
+                );
+        }
+
+        [Fact]
+        public void DefineAbstractStaticMethod_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static void M01();
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+
+                Assert.False(m01.IsMetadataNewSlot());
+                Assert.True(m01.IsAbstract);
+                Assert.True(m01.IsMetadataVirtual());
+                Assert.False(m01.IsMetadataFinal);
+                Assert.False(m01.IsVirtual);
+                Assert.False(m01.IsSealed);
+                Assert.True(m01.IsStatic);
+                Assert.False(m01.IsOverride);
+            }
+        }
+
+        [Fact]
+        public void DefineAbstractStaticMethod_02()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static void M01();
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation1.VerifyDiagnostics(
+                // (4,26): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(4, 26)
+                );
+        }
+
+        [Theory]
+        [InlineData("I1", "+", "(I1 x)")]
+        [InlineData("I1", "-", "(I1 x)")]
+        [InlineData("I1", "!", "(I1 x)")]
+        [InlineData("I1", "~", "(I1 x)")]
+        [InlineData("I1", "++", "(I1 x)")]
+        [InlineData("I1", "--", "(I1 x)")]
+        [InlineData("I1", "+", "(I1 x, I1 y)")]
+        [InlineData("I1", "-", "(I1 x, I1 y)")]
+        [InlineData("I1", "*", "(I1 x, I1 y)")]
+        [InlineData("I1", "/", "(I1 x, I1 y)")]
+        [InlineData("I1", "%", "(I1 x, I1 y)")]
+        [InlineData("I1", "&", "(I1 x, I1 y)")]
+        [InlineData("I1", "|", "(I1 x, I1 y)")]
+        [InlineData("I1", "^", "(I1 x, I1 y)")]
+        [InlineData("I1", "<<", "(I1 x, int y)")]
+        [InlineData("I1", ">>", "(I1 x, int y)")]
+        public void DefineAbstractStaticOperator_01(string type, string op, string paramList)
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static " + type + " operator " + op + " " + paramList + @";
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+
+                Assert.False(m01.IsMetadataNewSlot());
+                Assert.True(m01.IsAbstract);
+                Assert.True(m01.IsMetadataVirtual());
+                Assert.False(m01.IsMetadataFinal);
+                Assert.False(m01.IsVirtual);
+                Assert.False(m01.IsSealed);
+                Assert.True(m01.IsStatic);
+                Assert.False(m01.IsOverride);
+            }
+        }
+
+        [Fact]
+        public void DefineAbstractStaticOperator_02()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static bool operator true (I1 x);
+    abstract static bool operator false (I1 x);
+    abstract static I1 operator > (I1 x, I1 y);
+    abstract static I1 operator < (I1 x, I1 y);
+    abstract static I1 operator >= (I1 x, I1 y);
+    abstract static I1 operator <= (I1 x, I1 y);
+    abstract static I1 operator == (I1 x, I1 y);
+    abstract static I1 operator != (I1 x, I1 y);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                int count = 0;
+                foreach (var m01 in module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>())
+                {
+                    Assert.False(m01.IsMetadataNewSlot());
+                    Assert.True(m01.IsAbstract);
+                    Assert.True(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsMetadataFinal);
+                    Assert.False(m01.IsVirtual);
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsOverride);
+
+                    count++;
+                }
+
+                Assert.Equal(8, count);
+            }
+        }
+
+        [Theory]
+        [InlineData("I1", "+", "(I1 x)")]
+        [InlineData("I1", "-", "(I1 x)")]
+        [InlineData("I1", "!", "(I1 x)")]
+        [InlineData("I1", "~", "(I1 x)")]
+        [InlineData("I1", "++", "(I1 x)")]
+        [InlineData("I1", "--", "(I1 x)")]
+        [InlineData("I1", "+", "(I1 x, I1 y)")]
+        [InlineData("I1", "-", "(I1 x, I1 y)")]
+        [InlineData("I1", "*", "(I1 x, I1 y)")]
+        [InlineData("I1", "/", "(I1 x, I1 y)")]
+        [InlineData("I1", "%", "(I1 x, I1 y)")]
+        [InlineData("I1", "&", "(I1 x, I1 y)")]
+        [InlineData("I1", "|", "(I1 x, I1 y)")]
+        [InlineData("I1", "^", "(I1 x, I1 y)")]
+        [InlineData("I1", "<<", "(I1 x, int y)")]
+        [InlineData("I1", ">>", "(I1 x, int y)")]
+        public void DefineAbstractStaticOperator_03(string type, string op, string paramList)
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static " + type + " operator " + op + " " + paramList + @";
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation1.VerifyDiagnostics(
+                // (4,33): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator + (I1 x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(4, 31 + type.Length)
+                );
+        }
+
+        [Fact]
+        public void DefineAbstractStaticOperator_04()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static bool operator true (I1 x);
+    abstract static bool operator false (I1 x);
+    abstract static I1 operator > (I1 x, I1 y);
+    abstract static I1 operator < (I1 x, I1 y);
+    abstract static I1 operator >= (I1 x, I1 y);
+    abstract static I1 operator <= (I1 x, I1 y);
+    abstract static I1 operator == (I1 x, I1 y);
+    abstract static I1 operator != (I1 x, I1 y);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation1.VerifyDiagnostics(
+                // (4,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static bool operator true (I1 x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "true").WithLocation(4, 35),
+                // (5,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static bool operator false (I1 x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "false").WithLocation(5, 35),
+                // (6,33): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator > (I1 x, I1 y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, ">").WithLocation(6, 33),
+                // (7,33): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator < (I1 x, I1 y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "<").WithLocation(7, 33),
+                // (8,33): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator >= (I1 x, I1 y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, ">=").WithLocation(8, 33),
+                // (9,33): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator <= (I1 x, I1 y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "<=").WithLocation(9, 33),
+                // (10,33): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator == (I1 x, I1 y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "==").WithLocation(10, 33),
+                // (11,33): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator != (I1 x, I1 y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "!=").WithLocation(11, 33)
+                );
+        }
+
+        [Fact]
+        public void DefineAbstractStaticConversion_01()
+        {
+            var source1 =
+@"
+interface I1<T> where T : I1<T>
+{
+    abstract static implicit operator int(T x);
+    abstract static explicit operator T(int x);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                int count = 0;
+                foreach (var m01 in module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>())
+                {
+                    Assert.False(m01.IsMetadataNewSlot());
+                    Assert.True(m01.IsAbstract);
+                    Assert.True(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsMetadataFinal);
+                    Assert.False(m01.IsVirtual);
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsOverride);
+
+                    count++;
+                }
+
+                Assert.Equal(2, count);
+            }
+        }
+
+        [Fact]
+        public void DefineAbstractStaticConversion_03()
+        {
+            var source1 =
+@"
+interface I1<T> where T : I1<T>
+{
+    abstract static implicit operator int(T x);
+    abstract static explicit operator T(int x);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation1.VerifyDiagnostics(
+                // (4,39): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static implicit operator int(T x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "int").WithLocation(4, 39),
+                // (5,39): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static explicit operator T(int x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "T").WithLocation(5, 39)
+                );
+        }
+
+        [Fact]
+        public void DefineAbstractStaticProperty_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static int P01 { get; set; }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var p01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.True(p01.IsAbstract);
+                Assert.False(p01.IsVirtual);
+                Assert.False(p01.IsSealed);
+                Assert.True(p01.IsStatic);
+                Assert.False(p01.IsOverride);
+
+                int count = 0;
+                foreach (var m01 in module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>())
+                {
+                    Assert.False(m01.IsMetadataNewSlot());
+                    Assert.True(m01.IsAbstract);
+                    Assert.True(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsMetadataFinal);
+                    Assert.False(m01.IsVirtual);
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsOverride);
+
+                    count++;
+                }
+
+                Assert.Equal(2, count);
+            }
+        }
+
+        [Fact]
+        public void DefineAbstractStaticProperty_02()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static int P01 { get; set; }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation1.VerifyDiagnostics(
+                // (4,31): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "get").WithLocation(4, 31),
+                // (4,36): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "set").WithLocation(4, 36)
+                );
+        }
+
+        [Fact]
+        public void DefineAbstractStaticEvent_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static event System.Action E01;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var e01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.True(e01.IsAbstract);
+                Assert.False(e01.IsVirtual);
+                Assert.False(e01.IsSealed);
+                Assert.True(e01.IsStatic);
+                Assert.False(e01.IsOverride);
+
+                int count = 0;
+                foreach (var m01 in module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>())
+                {
+                    Assert.False(m01.IsMetadataNewSlot());
+                    Assert.True(m01.IsAbstract);
+                    Assert.True(m01.IsMetadataVirtual());
+                    Assert.False(m01.IsMetadataFinal);
+                    Assert.False(m01.IsVirtual);
+                    Assert.False(m01.IsSealed);
+                    Assert.True(m01.IsStatic);
+                    Assert.False(m01.IsOverride);
+
+                    count++;
+                }
+
+                Assert.Equal(2, count);
+            }
+        }
+
+        [Fact]
+        public void DefineAbstractStaticEvent_02()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static event System.Action E01;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation1.VerifyDiagnostics(
+                // (4,41): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static event System.Action E01;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "E01").WithLocation(4, 41)
+                );
+        }
+
+        [Fact]
+        public void ConstraintChecks_01()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+public interface I2 : I1
+{
+}
+
+public interface I3 : I2
+{
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var source2 =
+@"
+class C1<T1> where T1 : I1
+{
+    void Test(C1<I2> x)
+    {
+    }
+}
+
+class C2
+{
+    void M<T2>() where T2 : I1 {}
+
+    void Test(C2 x)
+    {
+        x.M<I2>();
+    }
+}
+
+class C3<T3> where T3 : I2
+{
+    void Test(C3<I2> x, C3<I3> y)
+    {
+    }
+}
+
+class C4
+{
+    void M<T4>() where T4 : I2 {}
+
+    void Test(C4 x)
+    {
+        x.M<I2>();
+        x.M<I3>();
+    }
+}
+
+class C5<T5> where T5 : I3
+{
+    void Test(C5<I3> y)
+    {
+    }
+}
+
+class C6
+{
+    void M<T6>() where T6 : I3 {}
+
+    void Test(C6 x)
+    {
+        x.M<I3>();
+    }
+}
+
+class C7<T7> where T7 : I1
+{
+    void Test(C7<I1> y)
+    {
+    }
+}
+
+class C8
+{
+    void M<T8>() where T8 : I1 {}
+
+    void Test(C8 x)
+    {
+        x.M<I1>();
+    }
+}
+";
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            var expected = new[] {
+                // (4,22): error CS8920: The interface 'I2' cannot be used as type parameter 'T1' in the generic type or method 'C1<T1>'. The constraint interface 'I1' or its base interface has static abstract members.
+                //     void Test(C1<I2> x)
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "x").WithArguments("C1<T1>", "I1", "T1", "I2").WithLocation(4, 22),
+                // (15,11): error CS8920: The interface 'I2' cannot be used as type parameter 'T2' in the generic type or method 'C2.M<T2>()'. The constraint interface 'I1' or its base interface has static abstract members.
+                //         x.M<I2>();
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "M<I2>").WithArguments("C2.M<T2>()", "I1", "T2", "I2").WithLocation(15, 11),
+                // (21,22): error CS8920: The interface 'I2' cannot be used as type parameter 'T3' in the generic type or method 'C3<T3>'. The constraint interface 'I2' or its base interface has static abstract members.
+                //     void Test(C3<I2> x, C3<I3> y)
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "x").WithArguments("C3<T3>", "I2", "T3", "I2").WithLocation(21, 22),
+                // (21,32): error CS8920: The interface 'I3' cannot be used as type parameter 'T3' in the generic type or method 'C3<T3>'. The constraint interface 'I2' or its base interface has static abstract members.
+                //     void Test(C3<I2> x, C3<I3> y)
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "y").WithArguments("C3<T3>", "I2", "T3", "I3").WithLocation(21, 32),
+                // (32,11): error CS8920: The interface 'I2' cannot be used as type parameter 'T4' in the generic type or method 'C4.M<T4>()'. The constraint interface 'I2' or its base interface has static abstract members.
+                //         x.M<I2>();
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "M<I2>").WithArguments("C4.M<T4>()", "I2", "T4", "I2").WithLocation(32, 11),
+                // (33,11): error CS8920: The interface 'I3' cannot be used as type parameter 'T4' in the generic type or method 'C4.M<T4>()'. The constraint interface 'I2' or its base interface has static abstract members.
+                //         x.M<I3>();
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "M<I3>").WithArguments("C4.M<T4>()", "I2", "T4", "I3").WithLocation(33, 11),
+                // (39,22): error CS8920: The interface 'I3' cannot be used as type parameter 'T5' in the generic type or method 'C5<T5>'. The constraint interface 'I3' or its base interface has static abstract members.
+                //     void Test(C5<I3> y)
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "y").WithArguments("C5<T5>", "I3", "T5", "I3").WithLocation(39, 22),
+                // (50,11): error CS8920: The interface 'I3' cannot be used as type parameter 'T6' in the generic type or method 'C6.M<T6>()'. The constraint interface 'I3' or its base interface has static abstract members.
+                //         x.M<I3>();
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "M<I3>").WithArguments("C6.M<T6>()", "I3", "T6", "I3").WithLocation(50, 11),
+                // (56,22): error CS8920: The interface 'I1' cannot be used as type parameter 'T7' in the generic type or method 'C7<T7>'. The constraint interface 'I1' or its base interface has static abstract members.
+                //     void Test(C7<I1> y)
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "y").WithArguments("C7<T7>", "I1", "T7", "I1").WithLocation(56, 22),
+                // (67,11): error CS8920: The interface 'I1' cannot be used as type parameter 'T8' in the generic type or method 'C8.M<T8>()'. The constraint interface 'I1' or its base interface has static abstract members.
+                //         x.M<I1>();
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedInterfaceWithStaticAbstractMembers, "M<I1>").WithArguments("C8.M<T8>()", "I1", "T8", "I1").WithLocation(67, 11)
+            };
+
+            compilation2.VerifyDiagnostics(expected);
+
+            compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.EmitToImageReference() });
+
+            compilation2.VerifyDiagnostics(expected);
+        }
+
+        [Fact]
+        public void ConstraintChecks_02()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+public class C : I1
+{
+    public static void M01() {}
+}
+
+public struct S : I1
+{
+    public static void M01() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var source2 =
+@"
+class C1<T1> where T1 : I1
+{
+    void Test(C1<C> x, C1<S> y, C1<T1> z)
+    {
+    }
+}
+
+class C2
+{
+    public void M<T2>(C2 x) where T2 : I1
+    {
+        x.M<T2>(x);
+    }
+
+    void Test(C2 x)
+    {
+        x.M<C>(x);
+        x.M<S>(x);
+    }
+}
+
+class C3<T3> where T3 : I1
+{
+    void Test(C1<T3> z)
+    {
+    }
+}
+
+class C4
+{
+    void M<T4>(C2 x) where T4 : I1
+    {
+        x.M<T4>(x);
+    }
+}
+
+class C5<T5>
+{
+    internal virtual void M<U5>() where U5 : T5 { }
+}
+
+class C6 : C5<I1>
+{
+    internal override void M<U6>() { base.M<U6>(); }
+}
+";
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyEmitDiagnostics();
+
+            compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.EmitToImageReference() });
+
+            compilation2.VerifyEmitDiagnostics();
+        }
+
+        [Fact]
+        public void VarianceSafety_01()
+        {
+            var source1 =
+@"
+interface I2<out T1, in T2>
+{
+    abstract static T1 P1 { get; }
+    abstract static T2 P2 { get; }
+    abstract static T1 P3 { set; }
+    abstract static T2 P4 { set; }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (5,21): error CS1961: Invalid variance: The type parameter 'T2' must be covariantly valid on 'I2<T1, T2>.P2'. 'T2' is contravariant.
+                //     abstract static T2 P2 { get; }
+                Diagnostic(ErrorCode.ERR_UnexpectedVariance, "T2").WithArguments("I2<T1, T2>.P2", "T2", "contravariant", "covariantly").WithLocation(5, 21),
+                // (6,21): error CS1961: Invalid variance: The type parameter 'T1' must be contravariantly valid on 'I2<T1, T2>.P3'. 'T1' is covariant.
+                //     abstract static T1 P3 { set; }
+                Diagnostic(ErrorCode.ERR_UnexpectedVariance, "T1").WithArguments("I2<T1, T2>.P3", "T1", "covariant", "contravariantly").WithLocation(6, 21)
+                );
+        }
+
+        [Fact]
+        public void VarianceSafety_02()
+        {
+            var source1 =
+@"
+interface I2<out T1, in T2>
+{
+    abstract static T1 M1();
+    abstract static T2 M2();
+    abstract static void M3(T1 x);
+    abstract static void M4(T2 x);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (5,21): error CS1961: Invalid variance: The type parameter 'T2' must be covariantly valid on 'I2<T1, T2>.M2()'. 'T2' is contravariant.
+                //     abstract static T2 M2();
+                Diagnostic(ErrorCode.ERR_UnexpectedVariance, "T2").WithArguments("I2<T1, T2>.M2()", "T2", "contravariant", "covariantly").WithLocation(5, 21),
+                // (6,29): error CS1961: Invalid variance: The type parameter 'T1' must be contravariantly valid on 'I2<T1, T2>.M3(T1)'. 'T1' is covariant.
+                //     abstract static void M3(T1 x);
+                Diagnostic(ErrorCode.ERR_UnexpectedVariance, "T1").WithArguments("I2<T1, T2>.M3(T1)", "T1", "covariant", "contravariantly").WithLocation(6, 29)
+                );
+        }
+
+        [Fact]
+        public void VarianceSafety_03()
+        {
+            var source1 =
+@"
+interface I2<out T1, in T2>
+{
+    abstract static event System.Action<System.Func<T1>> E1;
+    abstract static event System.Action<System.Func<T2>> E2;
+    abstract static event System.Action<System.Action<T1>> E3;
+    abstract static event System.Action<System.Action<T2>> E4;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (5,58): error CS1961: Invalid variance: The type parameter 'T2' must be covariantly valid on 'I2<T1, T2>.E2'. 'T2' is contravariant.
+                //     abstract static event System.Action<System.Func<T2>> E2;
+                Diagnostic(ErrorCode.ERR_UnexpectedVariance, "E2").WithArguments("I2<T1, T2>.E2", "T2", "contravariant", "covariantly").WithLocation(5, 58),
+                // (6,60): error CS1961: Invalid variance: The type parameter 'T1' must be contravariantly valid on 'I2<T1, T2>.E3'. 'T1' is covariant.
+                //     abstract static event System.Action<System.Action<T1>> E3;
+                Diagnostic(ErrorCode.ERR_UnexpectedVariance, "E3").WithArguments("I2<T1, T2>.E3", "T1", "covariant", "contravariantly").WithLocation(6, 60)
+                );
+        }
+
+        [Fact]
+        public void VarianceSafety_04()
+        {
+            var source1 =
+@"
+interface I2<out T2>
+{
+    abstract static int operator +(I2<T2> x);
+}
+
+interface I3<out T3>
+{
+    abstract static int operator +(I3<T3> x);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (4,36): error CS1961: Invalid variance: The type parameter 'T2' must be contravariantly valid on 'I2<T2>.operator +(I2<T2>)'. 'T2' is covariant.
+                //     abstract static int operator +(I2<T2> x);
+                Diagnostic(ErrorCode.ERR_UnexpectedVariance, "I2<T2>").WithArguments("I2<T2>.operator +(I2<T2>)", "T2", "covariant", "contravariantly").WithLocation(4, 36),
+                // (9,36): error CS1961: Invalid variance: The type parameter 'T3' must be contravariantly valid on 'I3<T3>.operator +(I3<T3>)'. 'T3' is covariant.
+                //     abstract static int operator +(I3<T3> x);
+                Diagnostic(ErrorCode.ERR_UnexpectedVariance, "I3<T3>").WithArguments("I3<T3>.operator +(I3<T3>)", "T3", "covariant", "contravariantly").WithLocation(9, 36)
+                );
+        }
+
+        [Theory]
+        [InlineData("+")]
+        [InlineData("-")]
+        [InlineData("!")]
+        [InlineData("~")]
+        [InlineData("true")]
+        [InlineData("false")]
+        public void OperatorSignature_01(string op)
+        {
+            var source1 =
+@"
+interface I1<T1> where T1 : I1<T1>
+{
+    static bool operator " + op + @"(T1 x) => throw null;
+}
+
+interface I2<T2> where T2 : struct, I2<T2>
+{
+    static bool operator " + op + @"(T2? x) => throw null;
+}
+
+interface I3<T3> where T3 : I3<T3>
+{
+    static abstract bool operator " + op + @"(T3 x);
+}
+
+interface I4<T4> where T4 : struct, I4<T4>
+{
+    static abstract bool operator " + op + @"(T4? x);
+}
+
+class C5<T5> where T5 : C5<T5>.I6
+{
+    public interface I6
+    {
+        static abstract bool operator " + op + @"(T5 x);
+    }
+}
+
+interface I7<T71, T72> where T72 : I7<T71, T72> where T71 : T72
+{
+    static abstract bool operator " + op + @"(T71 x);
+}
+
+interface I8<T8> where T8 : I9<T8>
+{
+    static abstract bool operator " + op + @"(T8 x);
+}
+
+interface I9<T9> : I8<T9> where T9 : I9<T9> {}
+
+interface I10<T10> where T10 : C11<T10>
+{
+    static abstract bool operator " + op + @"(T10 x);
+}
+
+class C11<T11> : I10<T11> where T11 : C11<T11> {}
+
+interface I12
+{
+    static abstract bool operator " + op + @"(int x);
+}
+
+interface I13
+{
+    static abstract bool operator " + op + @"(I13 x);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_OperatorNeedsMatch).Verify(
+                // (4,26): error CS0562: The parameter of a unary operator must be the containing type
+                //     static bool operator +(T1 x) => throw null;
+                Diagnostic(ErrorCode.ERR_BadUnaryOperatorSignature, op).WithLocation(4, 26),
+                // (9,26): error CS0562: The parameter of a unary operator must be the containing type
+                //     static bool operator +(T2? x) => throw null;
+                Diagnostic(ErrorCode.ERR_BadUnaryOperatorSignature, op).WithLocation(9, 26),
+                // (26,39): error CS8921: The parameter of a unary operator must be the containing type, or its type parameter constrained to it.
+                //         static abstract bool operator +(T5 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractUnaryOperatorSignature, op).WithLocation(26, 39),
+                // (32,35): error CS8921: The parameter of a unary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(T71 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractUnaryOperatorSignature, op).WithLocation(32, 35),
+                // (37,35): error CS8921: The parameter of a unary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(T8 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractUnaryOperatorSignature, op).WithLocation(37, 35),
+                // (44,35): error CS8921: The parameter of a unary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(T10 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractUnaryOperatorSignature, op).WithLocation(44, 35),
+                // (47,18): error CS0535: 'C11<T11>' does not implement interface member 'I10<T11>.operator false(T11)'
+                // class C11<T11> : I10<T11> where T11 : C11<T11> {}
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I10<T11>").WithArguments("C11<T11>", "I10<T11>.operator " + op + "(T11)").WithLocation(47, 18),
+                // (51,35): error CS8921: The parameter of a unary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator false(int x);
+                Diagnostic(ErrorCode.ERR_BadAbstractUnaryOperatorSignature, op).WithLocation(51, 35)
+                );
+        }
+
+        [Theory]
+        [InlineData("++")]
+        [InlineData("--")]
+        public void OperatorSignature_02(string op)
+        {
+            var source1 =
+@"
+interface I1<T1> where T1 : I1<T1>
+{
+    static T1 operator " + op + @"(T1 x) => throw null;
+}
+
+interface I2<T2> where T2 : struct, I2<T2>
+{
+    static T2? operator " + op + @"(T2? x) => throw null;
+}
+
+interface I3<T3> where T3 : I3<T3>
+{
+    static abstract T3 operator " + op + @"(T3 x);
+}
+
+interface I4<T4> where T4 : struct, I4<T4>
+{
+    static abstract T4? operator " + op + @"(T4? x);
+}
+
+class C5<T5> where T5 : C5<T5>.I6
+{
+    public interface I6
+    {
+        static abstract T5 operator " + op + @"(T5 x);
+    }
+}
+
+interface I7<T71, T72> where T72 : I7<T71, T72> where T71 : T72
+{
+    static abstract T71 operator " + op + @"(T71 x);
+}
+
+interface I8<T8> where T8 : I9<T8>
+{
+    static abstract T8 operator " + op + @"(T8 x);
+}
+
+interface I9<T9> : I8<T9> where T9 : I9<T9> {}
+
+interface I10<T10> where T10 : C11<T10>
+{
+    static abstract T10 operator " + op + @"(T10 x);
+}
+
+class C11<T11> : I10<T11> where T11 : C11<T11> {}
+
+interface I12
+{
+    static abstract int operator " + op + @"(int x);
+}
+
+interface I13
+{
+    static abstract I13 operator " + op + @"(I13 x);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (4,24): error CS0559: The parameter type for ++ or -- operator must be the containing type
+                //     static T1 operator ++(T1 x) => throw null;
+                Diagnostic(ErrorCode.ERR_BadIncDecSignature, op).WithLocation(4, 24),
+                // (9,25): error CS0559: The parameter type for ++ or -- operator must be the containing type
+                //     static T2? operator ++(T2? x) => throw null;
+                Diagnostic(ErrorCode.ERR_BadIncDecSignature, op).WithLocation(9, 25),
+                // (26,37): error CS8922: The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.
+                //         static abstract T5 operator ++(T5 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecSignature, op).WithLocation(26, 37),
+                // (32,34): error CS8922: The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract T71 operator ++(T71 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecSignature, op).WithLocation(32, 34),
+                // (37,33): error CS8922: The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract T8 operator ++(T8 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecSignature, op).WithLocation(37, 33),
+                // (44,34): error CS8922: The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract T10 operator ++(T10 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecSignature, op).WithLocation(44, 34),
+                // (47,18): error CS0535: 'C11<T11>' does not implement interface member 'I10<T11>.operator --(T11)'
+                // class C11<T11> : I10<T11> where T11 : C11<T11> {}
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I10<T11>").WithArguments("C11<T11>", "I10<T11>.operator " + op + "(T11)").WithLocation(47, 18),
+                // (51,34): error CS8922: The parameter type for ++ or -- operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract int operator ++(int x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecSignature, op).WithLocation(51, 34)
+                );
+        }
+
+        [Theory]
+        [InlineData("++")]
+        [InlineData("--")]
+        public void OperatorSignature_03(string op)
+        {
+            var source1 =
+@"
+interface I1<T1> where T1 : I1<T1>
+{
+    static T1 operator " + op + @"(I1<T1> x) => throw null;
+}
+
+interface I2<T2> where T2 : struct, I2<T2>
+{
+    static T2? operator " + op + @"(I2<T2> x) => throw null;
+}
+
+interface I3<T3> where T3 : I3<T3>
+{
+    static abstract T3 operator " + op + @"(I3<T3> x);
+}
+
+interface I4<T4> where T4 : struct, I4<T4>
+{
+    static abstract T4? operator " + op + @"(I4<T4> x);
+}
+
+class C5<T5> where T5 : C5<T5>.I6
+{
+    public interface I6
+    {
+        static abstract T5 operator " + op + @"(I6 x);
+    }
+}
+
+interface I7<T71, T72> where T72 : I7<T71, T72> where T71 : T72
+{
+    static abstract T71 operator " + op + @"(I7<T71, T72> x);
+}
+
+interface I8<T8> where T8 : I9<T8>
+{
+    static abstract T8 operator " + op + @"(I8<T8> x);
+}
+
+interface I9<T9> : I8<T9> where T9 : I9<T9> {}
+
+interface I10<T10> where T10 : C11<T10>
+{
+    static abstract T10 operator " + op + @"(I10<T10> x);
+}
+
+class C11<T11> : I10<T11> where T11 : C11<T11> {}
+
+interface I12
+{
+    static abstract int operator " + op + @"(I12 x);
+}
+
+interface I13<T13> where T13 : struct, I13<T13>
+{
+    static abstract T13? operator " + op + @"(T13 x);
+}
+
+interface I14<T14> where T14 : struct, I14<T14>
+{
+    static abstract T14 operator " + op + @"(T14? x);
+}
+
+interface I15<T151, T152> where T151 : I15<T151, T152> where T152 : I15<T151, T152>
+{
+    static abstract T151 operator " + op + @"(T152 x);
+}
+
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (4,24): error CS0448: The return type for ++ or -- operator must match the parameter type or be derived from the parameter type
+                //     static T1 operator ++(I1<T1> x) => throw null;
+                Diagnostic(ErrorCode.ERR_BadIncDecRetType, op).WithLocation(4, 24),
+                // (9,25): error CS0448: The return type for ++ or -- operator must match the parameter type or be derived from the parameter type
+                //     static T2? operator ++(I2<T2> x) => throw null;
+                Diagnostic(ErrorCode.ERR_BadIncDecRetType, op).WithLocation(9, 25),
+                // (19,34): error CS8923: The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.
+                //     static abstract T4? operator ++(I4<T4> x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecRetType, op).WithLocation(19, 34),
+                // (26,37): error CS8923: The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.
+                //         static abstract T5 operator ++(I6 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecRetType, op).WithLocation(26, 37),
+                // (32,34): error CS8923: The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.
+                //     static abstract T71 operator ++(I7<T71, T72> x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecRetType, op).WithLocation(32, 34),
+                // (37,33): error CS8923: The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.
+                //     static abstract T8 operator ++(I8<T8> x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecRetType, op).WithLocation(37, 33),
+                // (44,34): error CS8923: The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.
+                //     static abstract T10 operator ++(I10<T10> x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecRetType, op).WithLocation(44, 34),
+                // (47,18): error CS0535: 'C11<T11>' does not implement interface member 'I10<T11>.operator ++(I10<T11>)'
+                // class C11<T11> : I10<T11> where T11 : C11<T11> {}
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I10<T11>").WithArguments("C11<T11>", "I10<T11>.operator " + op + "(I10<T11>)").WithLocation(47, 18),
+                // (51,34): error CS8923: The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.
+                //     static abstract int operator ++(I12 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecRetType, op).WithLocation(51, 34),
+                // (56,35): error CS8923: The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.
+                //     static abstract T13? operator ++(T13 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecRetType, op).WithLocation(56, 35),
+                // (61,34): error CS8923: The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.
+                //     static abstract T14 operator ++(T14? x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecRetType, op).WithLocation(61, 34),
+                // (66,35): error CS8923: The return type for ++ or -- operator must either match the parameter type, or be derived from the parameter type, or be the containing type's type parameter constrained to it unless the parameter type is a different type parameter.
+                //     static abstract T151 operator ++(T152 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractIncDecRetType, op).WithLocation(66, 35)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void OperatorSignature_04([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            var source1 =
+@"
+interface I1<T1> where T1 : I1<T1>
+{
+    static bool operator " + op + @"(T1 x, bool y) => throw null;
+}
+
+interface I2<T2> where T2 : struct, I2<T2>
+{
+    static bool operator " + op + @"(T2? x, bool y) => throw null;
+}
+
+interface I3<T3> where T3 : I3<T3>
+{
+    static abstract bool operator " + op + @"(T3 x, bool y);
+}
+
+interface I4<T4> where T4 : struct, I4<T4>
+{
+    static abstract bool operator " + op + @"(T4? x, bool y);
+}
+
+class C5<T5> where T5 : C5<T5>.I6
+{
+    public interface I6
+    {
+        static abstract bool operator " + op + @"(T5 x, bool y);
+    }
+}
+
+interface I7<T71, T72> where T72 : I7<T71, T72> where T71 : T72
+{
+    static abstract bool operator " + op + @"(T71 x, bool y);
+}
+
+interface I8<T8> where T8 : I9<T8>
+{
+    static abstract bool operator " + op + @"(T8 x, bool y);
+}
+
+interface I9<T9> : I8<T9> where T9 : I9<T9> {}
+
+interface I10<T10> where T10 : C11<T10>
+{
+    static abstract bool operator " + op + @"(T10 x, bool y);
+}
+
+class C11<T11> : I10<T11> where T11 : C11<T11> {}
+
+interface I12
+{
+    static abstract bool operator " + op + @"(int x, bool y);
+}
+
+interface I13
+{
+    static abstract bool operator " + op + @"(I13 x, bool y);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators)).Verify(
+                // (4,26): error CS0563: One of the parameters of a binary operator must be the containing type
+                //     static bool operator +(T1 x, bool y) => throw null;
+                Diagnostic(ErrorCode.ERR_BadBinaryOperatorSignature, op).WithLocation(4, 26),
+                // (9,26): error CS0563: One of the parameters of a binary operator must be the containing type
+                //     static bool operator +(T2? x, bool y) => throw null;
+                Diagnostic(ErrorCode.ERR_BadBinaryOperatorSignature, op).WithLocation(9, 26),
+                // (26,39): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //         static abstract bool operator +(T5 x, bool y);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(26, 39),
+                // (32,35): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(T71 x, bool y);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(32, 35),
+                // (37,35): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(T8 x, bool y);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(37, 35),
+                // (44,35): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(T10 x, bool y);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(44, 35),
+                // (47,18): error CS0535: 'C11<T11>' does not implement interface member 'I10<T11>.operator /(T11, bool)'
+                // class C11<T11> : I10<T11> where T11 : C11<T11> {}
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I10<T11>").WithArguments("C11<T11>", "I10<T11>.operator " + op + "(T11, bool)").WithLocation(47, 18),
+                // (51,35): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(int x, bool y);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(51, 35)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void OperatorSignature_05([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            var source1 =
+@"
+interface I1<T1> where T1 : I1<T1>
+{
+    static bool operator " + op + @"(bool y, T1 x) => throw null;
+}
+
+interface I2<T2> where T2 : struct, I2<T2>
+{
+    static bool operator " + op + @"(bool y, T2? x) => throw null;
+}
+
+interface I3<T3> where T3 : I3<T3>
+{
+    static abstract bool operator " + op + @"(bool y, T3 x);
+}
+
+interface I4<T4> where T4 : struct, I4<T4>
+{
+    static abstract bool operator " + op + @"(bool y, T4? x);
+}
+
+class C5<T5> where T5 : C5<T5>.I6
+{
+    public interface I6
+    {
+        static abstract bool operator " + op + @"(bool y, T5 x);
+    }
+}
+
+interface I7<T71, T72> where T72 : I7<T71, T72> where T71 : T72
+{
+    static abstract bool operator " + op + @"(bool y, T71 x);
+}
+
+interface I8<T8> where T8 : I9<T8>
+{
+    static abstract bool operator " + op + @"(bool y, T8 x);
+}
+
+interface I9<T9> : I8<T9> where T9 : I9<T9> {}
+
+interface I10<T10> where T10 : C11<T10>
+{
+    static abstract bool operator " + op + @"(bool y, T10 x);
+}
+
+class C11<T11> : I10<T11> where T11 : C11<T11> {}
+
+interface I12
+{
+    static abstract bool operator " + op + @"(bool y, int x);
+}
+
+interface I13
+{
+    static abstract bool operator " + op + @"(bool y, I13 x);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators)).Verify(
+                // (4,26): error CS0563: One of the parameters of a binary operator must be the containing type
+                //     static bool operator +(bool y, T1 x) => throw null;
+                Diagnostic(ErrorCode.ERR_BadBinaryOperatorSignature, op).WithLocation(4, 26),
+                // (9,26): error CS0563: One of the parameters of a binary operator must be the containing type
+                //     static bool operator +(bool y, T2? x) => throw null;
+                Diagnostic(ErrorCode.ERR_BadBinaryOperatorSignature, op).WithLocation(9, 26),
+                // (26,39): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //         static abstract bool operator +(bool y, T5 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(26, 39),
+                // (32,35): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(bool y, T71 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(32, 35),
+                // (37,35): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(bool y, T8 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(37, 35),
+                // (44,35): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(bool y, T10 x);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(44, 35),
+                // (47,18): error CS0535: 'C11<T11>' does not implement interface member 'I10<T11>.operator <=(bool, T11)'
+                // class C11<T11> : I10<T11> where T11 : C11<T11> {}
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I10<T11>").WithArguments("C11<T11>", "I10<T11>.operator " + op + "(bool, T11)").WithLocation(47, 18),
+                // (51,35): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //     static abstract bool operator +(bool y, int x);
+                Diagnostic(ErrorCode.ERR_BadAbstractBinaryOperatorSignature, op).WithLocation(51, 35)
+                );
+        }
+
+        [Theory]
+        [InlineData("<<")]
+        [InlineData(">>")]
+        public void OperatorSignature_06(string op)
+        {
+            var source1 =
+@"
+interface I1<T1> where T1 : I1<T1>
+{
+    static bool operator " + op + @"(T1 x, int y) => throw null;
+}
+
+interface I2<T2> where T2 : struct, I2<T2>
+{
+    static bool operator " + op + @"(T2? x, int y) => throw null;
+}
+
+interface I3<T3> where T3 : I3<T3>
+{
+    static abstract bool operator " + op + @"(T3 x, int y);
+}
+
+interface I4<T4> where T4 : struct, I4<T4>
+{
+    static abstract bool operator " + op + @"(T4? x, int y);
+}
+
+class C5<T5> where T5 : C5<T5>.I6
+{
+    public interface I6
+    {
+        static abstract bool operator " + op + @"(T5 x, int y);
+    }
+}
+
+interface I7<T71, T72> where T72 : I7<T71, T72> where T71 : T72
+{
+    static abstract bool operator " + op + @"(T71 x, int y);
+}
+
+interface I8<T8> where T8 : I9<T8>
+{
+    static abstract bool operator " + op + @"(T8 x, int y);
+}
+
+interface I9<T9> : I8<T9> where T9 : I9<T9> {}
+
+interface I10<T10> where T10 : C11<T10>
+{
+    static abstract bool operator " + op + @"(T10 x, int y);
+}
+
+class C11<T11> : I10<T11> where T11 : C11<T11> {}
+
+interface I12
+{
+    static abstract bool operator " + op + @"(int x, int y);
+}
+
+interface I13
+{
+    static abstract bool operator " + op + @"(I13 x, int y);
+}
+
+interface I14
+{
+    static abstract bool operator " + op + @"(I14 x, bool y);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_OperatorNeedsMatch).Verify(
+                // (4,26): error CS0564: The first operand of an overloaded shift operator must have the same type as the containing type, and the type of the second operand must be int
+                //     static bool operator <<(T1 x, int y) => throw null;
+                Diagnostic(ErrorCode.ERR_BadShiftOperatorSignature, op).WithLocation(4, 26),
+                // (9,26): error CS0564: The first operand of an overloaded shift operator must have the same type as the containing type, and the type of the second operand must be int
+                //     static bool operator <<(T2? x, int y) => throw null;
+                Diagnostic(ErrorCode.ERR_BadShiftOperatorSignature, op).WithLocation(9, 26),
+                // (26,39): error CS8925: The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int
+                //         static abstract bool operator <<(T5 x, int y);
+                Diagnostic(ErrorCode.ERR_BadAbstractShiftOperatorSignature, op).WithLocation(26, 39),
+                // (32,35): error CS8925: The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int
+                //     static abstract bool operator <<(T71 x, int y);
+                Diagnostic(ErrorCode.ERR_BadAbstractShiftOperatorSignature, op).WithLocation(32, 35),
+                // (37,35): error CS8925: The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int
+                //     static abstract bool operator <<(T8 x, int y);
+                Diagnostic(ErrorCode.ERR_BadAbstractShiftOperatorSignature, op).WithLocation(37, 35),
+                // (44,35): error CS8925: The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int
+                //     static abstract bool operator <<(T10 x, int y);
+                Diagnostic(ErrorCode.ERR_BadAbstractShiftOperatorSignature, op).WithLocation(44, 35),
+                // (47,18): error CS0535: 'C11<T11>' does not implement interface member 'I10<T11>.operator >>(T11, int)'
+                // class C11<T11> : I10<T11> where T11 : C11<T11> {}
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I10<T11>").WithArguments("C11<T11>", "I10<T11>.operator " + op + "(T11, int)").WithLocation(47, 18),
+                // (51,35): error CS8925: The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int
+                //     static abstract bool operator <<(int x, int y);
+                Diagnostic(ErrorCode.ERR_BadAbstractShiftOperatorSignature, op).WithLocation(51, 35),
+                // (61,35): error CS8925: The first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int
+                //     static abstract bool operator <<(I14 x, bool y);
+                Diagnostic(ErrorCode.ERR_BadAbstractShiftOperatorSignature, op).WithLocation(61, 35)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void OperatorSignature_07([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            var source1 =
+@"
+interface I1<T1> where T1 : I1<T1>
+{
+    abstract static " + op + @" operator T1(T1 y);
+}
+
+interface I2<T2> where T2 : I2<T2>
+{
+    abstract static " + op + @" operator dynamic(T2 y);
+}
+
+interface I3<T3> where T3 : I3<T3>
+{
+    static abstract " + op + @" operator T3(bool y);
+}
+
+interface I4<T4> where T4 : struct, I4<T4>
+{
+    static abstract " + op + @" operator T4?(bool y);
+}
+
+class C5<T5> where T5 : C5<T5>.I6
+{
+    public interface I6
+    {
+        static abstract " + op + @" operator T5 (bool y);
+    }
+}
+
+interface I7<T71, T72> where T72 : I7<T71, T72> where T71 : T72
+{
+    static abstract " + op + @" operator T71 (bool y);
+}
+
+interface I8<T8> where T8 : I9<T8>
+{
+    static abstract " + op + @" operator T8(bool y);
+}
+
+interface I9<T9> : I8<T9> where T9 : I9<T9> {}
+
+interface I10<T10> where T10 : C11<T10>
+{
+    static abstract " + op + @" operator T10(bool y);
+}
+
+class C11<T11> : I10<T11> where T11 : C11<T11> {}
+
+interface I12
+{
+    static abstract " + op + @" operator int(bool y);
+}
+
+interface I13
+{
+    static abstract " + op + @" operator I13(bool y);
+}
+
+interface I14<T14> where T14 : I14<T14>
+{
+    abstract static " + op + @" operator object(T14 y);
+}
+
+class C15 {}
+class C16 : C15 {}
+
+interface I17<T17> where T17 : C15, I17<T17>
+{
+    abstract static " + op + @" operator C16(T17 y);
+}
+
+interface I18<T18> where T18 : C16, I18<T18>
+{
+    abstract static " + op + @" operator C15(T18 y);
+}
+
+interface I19<T19_1, T19_2> where T19_1 : I19<T19_1, T19_2>, T19_2
+{
+    abstract static " + op + @" operator T19_1(T19_2 y);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (4,39): error CS0555: User-defined operator cannot convert a type to itself
+                //     abstract static explicit operator T1(T1 y);
+                Diagnostic(ErrorCode.ERR_IdentityConversion, "T1").WithLocation(4, 39),
+                // (9,39): error CS1964: 'I2<T2>.explicit operator dynamic(T2)': user-defined conversions to or from the dynamic type are not allowed
+                //     abstract static explicit operator dynamic(T2 y);
+                Diagnostic(ErrorCode.ERR_BadDynamicConversion, "dynamic").WithArguments("I2<T2>." + op + " operator dynamic(T2)").WithLocation(9, 39),
+                // (26,43): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //         static abstract explicit operator T5 (bool y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "T5").WithLocation(26, 43),
+                // (32,39): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //     static abstract explicit operator T71 (bool y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "T71").WithLocation(32, 39),
+                // (37,39): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //     static abstract explicit operator T8(bool y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "T8").WithLocation(37, 39),
+                // (44,39): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //     static abstract explicit operator T10(bool y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "T10").WithLocation(44, 39),
+                // (47,18): error CS0535: 'C11<T11>' does not implement interface member 'I10<T11>.explicit operator T11(bool)'
+                // class C11<T11> : I10<T11> where T11 : C11<T11> {}
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I10<T11>").WithArguments("C11<T11>", "I10<T11>." + op + " operator T11(bool)").WithLocation(47, 18),
+                // (51,39): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //     static abstract explicit operator int(bool y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "int").WithLocation(51, 39),
+                // (56,39): error CS0552: 'I13.explicit operator I13(bool)': user-defined conversions to or from an interface are not allowed
+                //     static abstract explicit operator I13(bool y);
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "I13").WithArguments("I13." + op + " operator I13(bool)").WithLocation(56, 39)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void OperatorSignature_08([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            var source1 =
+@"
+interface I1<T1> where T1 : I1<T1>
+{
+    abstract static " + op + @" operator T1(T1 y);
+}
+
+interface I2<T2> where T2 : I2<T2>
+{
+    abstract static " + op + @" operator T2(dynamic y);
+}
+
+interface I3<T3> where T3 : I3<T3>
+{
+    static abstract " + op + @" operator bool(T3 y);
+}
+
+interface I4<T4> where T4 : struct, I4<T4>
+{
+    static abstract " + op + @" operator bool(T4? y);
+}
+
+class C5<T5> where T5 : C5<T5>.I6
+{
+    public interface I6
+    {
+        static abstract " + op + @" operator bool(T5 y);
+    }
+}
+
+interface I7<T71, T72> where T72 : I7<T71, T72> where T71 : T72
+{
+    static abstract " + op + @" operator bool(T71 y);
+}
+
+interface I8<T8> where T8 : I9<T8>
+{
+    static abstract " + op + @" operator bool(T8 y);
+}
+
+interface I9<T9> : I8<T9> where T9 : I9<T9> {}
+
+interface I10<T10> where T10 : C11<T10>
+{
+    static abstract " + op + @" operator bool(T10 y);
+}
+
+class C11<T11> : I10<T11> where T11 : C11<T11> {}
+
+interface I12
+{
+    static abstract " + op + @" operator bool(int y);
+}
+
+interface I13
+{
+    static abstract " + op + @" operator bool(I13 y);
+}
+
+interface I14<T14> where T14 : I14<T14>
+{
+    abstract static " + op + @" operator T14(object y);
+}
+
+class C15 {}
+class C16 : C15 {}
+
+interface I17<T17> where T17 : C15, I17<T17>
+{
+    abstract static " + op + @" operator T17(C16 y);
+}
+
+interface I18<T18> where T18 : C16, I18<T18>
+{
+    abstract static " + op + @" operator T18(C15 y);
+}
+
+interface I19<T19_1, T19_2> where T19_1 : I19<T19_1, T19_2>, T19_2
+{
+    abstract static " + op + @" operator T19_2(T19_1 y);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (4,39): error CS0555: User-defined operator cannot convert a type to itself
+                //     abstract static explicit operator T1(T1 y);
+                Diagnostic(ErrorCode.ERR_IdentityConversion, "T1").WithLocation(4, 39),
+                // (9,39): error CS1964: 'I2<T2>.explicit operator T2(dynamic)': user-defined conversions to or from the dynamic type are not allowed
+                //     abstract static explicit operator T2(dynamic y);
+                Diagnostic(ErrorCode.ERR_BadDynamicConversion, "T2").WithArguments("I2<T2>." + op + " operator T2(dynamic)").WithLocation(9, 39),
+                // (26,43): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //         static abstract explicit operator bool(T5 y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "bool").WithLocation(26, 43),
+                // (32,39): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //     static abstract explicit operator bool(T71 y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "bool").WithLocation(32, 39),
+                // (37,39): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //     static abstract explicit operator bool(T8 y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "bool").WithLocation(37, 39),
+                // (44,39): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //     static abstract explicit operator bool(T10 y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "bool").WithLocation(44, 39),
+                // (47,18): error CS0535: 'C11<T11>' does not implement interface member 'I10<T11>.explicit operator bool(T11)'
+                // class C11<T11> : I10<T11> where T11 : C11<T11> {}
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I10<T11>").WithArguments("C11<T11>", "I10<T11>." + op + " operator bool(T11)").WithLocation(47, 18),
+                // (51,39): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //     static abstract explicit operator bool(int y);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "bool").WithLocation(51, 39),
+                // (56,39): error CS0552: 'I13.explicit operator bool(I13)': user-defined conversions to or from an interface are not allowed
+                //     static abstract explicit operator bool(I13 y);
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "bool").WithArguments("I13." + op + " operator bool(I13)").WithLocation(56, 39)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static void M01();
+
+    static void M02()
+    {
+        M01();
+        M04();
+    }
+
+    void M03()
+    {
+        this.M01();
+        this.M04();
+    }
+
+    static void M04() {}
+
+    protected abstract static void M05();
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        I1.M01();
+        x.M01();
+        I1.M04();
+        x.M04();
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        T.M03();
+        T.M04();
+        T.M00();
+        T.M05();
+
+        _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.M01());
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         M01();
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "M01").WithLocation(8, 9),
+                // (14,9): error CS0176: Member 'I1.M01()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.M01();
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.M01").WithArguments("I1.M01()").WithLocation(14, 9),
+                // (15,9): error CS0176: Member 'I1.M04()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.M04();
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.M04").WithArguments("I1.M04()").WithLocation(15, 9),
+                // (27,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         I1.M01();
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "I1.M01").WithLocation(27, 9),
+                // (28,9): error CS0176: Member 'I1.M01()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.M01();
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.M01").WithArguments("I1.M01()").WithLocation(28, 9),
+                // (30,9): error CS0176: Member 'I1.M04()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.M04();
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.M04").WithArguments("I1.M04()").WithLocation(30, 9),
+                // (35,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.M03();
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 9),
+                // (36,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.M04();
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 9),
+                // (37,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.M00();
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 9),
+                // (38,11): error CS0122: 'I1.M05()' is inaccessible due to its protection level
+                //         T.M05();
+                Diagnostic(ErrorCode.ERR_BadAccess, "M05").WithArguments("I1.M05()").WithLocation(38, 11),
+                // (40,71): error CS8927: An expression tree may not contain an access of static abstract interface member
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.M01());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, "T.M01()").WithLocation(40, 71)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_02()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static void M01();
+
+    static void M02()
+    {
+        _ = nameof(M01);
+        _ = nameof(M04);
+    }
+
+    void M03()
+    {
+        _ = nameof(this.M01);
+        _ = nameof(this.M04);
+    }
+
+    static void M04() {}
+
+    protected abstract static void M05();
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        _ = nameof(I1.M01);
+        _ = nameof(x.M01);
+        _ = nameof(I1.M04);
+        _ = nameof(x.M04);
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = nameof(T.M03);
+        _ = nameof(T.M04);
+        _ = nameof(T.M00);
+        _ = nameof(T.M05);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (35,20): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = nameof(T.M03);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 20),
+                // (36,20): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = nameof(T.M04);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 20),
+                // (37,20): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = nameof(T.M00);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 20),
+                // (38,22): error CS0122: 'I1.M05()' is inaccessible due to its protection level
+                //         _ = nameof(T.M05);
+                Diagnostic(ErrorCode.ERR_BadAccess, "M05").WithArguments("I1.M05()").WithLocation(38, 22)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+    abstract static void M04(int x);
+}
+
+class Test
+{
+    static void M02<T, U>() where T : U where U : I1
+    {
+        T.M01();
+    }
+
+    static string M03<T, U>() where T : U where U : I1
+    {
+        return nameof(T.M01);
+    }
+
+    static async void M05<T, U>() where T : U where U : I1
+    {
+        T.M04(await System.Threading.Tasks.Task.FromResult(1));
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       14 (0xe)
+  .maxstack  0
+  IL_0000:  nop
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""void I1.M01()""
+  IL_000c:  nop
+  IL_000d:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M03<T, U>()",
+@"
+{
+  // Code size       11 (0xb)
+  .maxstack  1
+  .locals init (string V_0)
+  IL_0000:  nop
+  IL_0001:  ldstr      ""M01""
+  IL_0006:  stloc.0
+  IL_0007:  br.s       IL_0009
+  IL_0009:  ldloc.0
+  IL_000a:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       12 (0xc)
+  .maxstack  0
+  IL_0000:  constrained. ""T""
+  IL_0006:  call       ""void I1.M01()""
+  IL_000b:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M03<T, U>()",
+@"
+{
+  // Code size        6 (0x6)
+  .maxstack  1
+  IL_0000:  ldstr      ""M01""
+  IL_0005:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().First();
+
+            Assert.Equal("T.M01()", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" qualifier is important for this invocation, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IInvocationOperation (virtual void I1.M01()) (OperationKind.Invocation, Type: System.Void) (Syntax: 'T.M01()')
+  Instance Receiver: 
+    null
+  Arguments(0)
+");
+
+            var m02 = compilation1.GetMember<MethodSymbol>("Test.M02");
+
+            Assert.Equal("void I1.M01()", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "M01").Single().ToTestDisplayString());
+            Assert.Contains("void I1.M01()", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+            Assert.Equal("void I1.M01()", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "M01").Single().ToTestDisplayString());
+            Assert.Contains("void I1.M01()", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+
+            Assert.Equal("void I1.M01()", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "M01").Single().ToTestDisplayString());
+            Assert.Contains("void I1.M01()", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+            Assert.Equal("void I1.M01()", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "M01").Single().ToTestDisplayString());
+            Assert.Contains("void I1.M01()", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+
+            Assert.Contains("M01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()));
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.M01();
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         T.M01();
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "T.M01").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,26): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(12, 26)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_05()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 Select(System.Func<int, int> p);
+}
+
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        _ = from t in T select t + 1;
+        _ = from t in I1 select t + 1;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            // https://github.com/dotnet/roslyn/issues/53796: Confirm whether we want to enable the 'from t in T' scenario.
+            compilation1.VerifyDiagnostics(
+                // (11,23): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = from t in T select t + 1;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(11, 23),
+                // (12,26): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = from t in I1 select t + 1;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "select t + 1").WithLocation(12, 26)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.M01();
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.M01();
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.M01();
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9),
+                // (12,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(12, 26)
+                );
+        }
+
+        [Theory]
+        [InlineData("+", "")]
+        [InlineData("-", "")]
+        [InlineData("!", "")]
+        [InlineData("~", "")]
+        [InlineData("++", "")]
+        [InlineData("--", "")]
+        [InlineData("", "++")]
+        [InlineData("", "--")]
+        public void ConsumeAbstractUnaryOperator_01(string prefixOp, string postfixOp)
+        {
+            var source1 =
+@"
+interface I1<T> where T : I1<T>
+{
+    abstract static T operator" + prefixOp + postfixOp + @" (T x);
+    abstract static I1<T> operator" + prefixOp + postfixOp + @" (I1<T> x);
+    static void M02(I1<T> x)
+    {
+        _ = " + prefixOp + "x" + postfixOp + @";
+    }
+
+    void M03(I1<T> y)
+    {
+        _ = " + prefixOp + "y" + postfixOp + @";
+    }
+}
+
+class Test<T> where T : I1<T>
+{
+    static void MT1(I1<T> a)
+    {
+        _ = " + prefixOp + "a" + postfixOp + @";
+    }
+
+    static void MT2()
+    {
+        _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (" + prefixOp + "b" + postfixOp + @").ToString());
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = -x;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, prefixOp + "x" + postfixOp).WithLocation(8, 13),
+                // (13,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = -y;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, prefixOp + "y" + postfixOp).WithLocation(13, 13),
+                // (21,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = -a;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, prefixOp + "a" + postfixOp).WithLocation(21, 13),
+                (prefixOp + postfixOp).Length == 1 ?
+                    // (26,78): error CS8927: An expression tree may not contain an access of static abstract interface member
+                    //         _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (-b).ToString());
+                    Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, prefixOp + "b" + postfixOp).WithLocation(26, 78)
+                    :
+                    // (26,78): error CS0832: An expression tree may not contain an assignment operator
+                    //         _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (b--).ToString());
+                    Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAssignment, prefixOp + "b" + postfixOp).WithLocation(26, 78)
+                );
+        }
+
+        [Theory]
+        [InlineData("+", "", "op_UnaryPlus", "Plus")]
+        [InlineData("-", "", "op_UnaryNegation", "Minus")]
+        [InlineData("!", "", "op_LogicalNot", "Not")]
+        [InlineData("~", "", "op_OnesComplement", "BitwiseNegation")]
+        [InlineData("++", "", "op_Increment", "Increment")]
+        [InlineData("--", "", "op_Decrement", "Decrement")]
+        [InlineData("", "++", "op_Increment", "Increment")]
+        [InlineData("", "--", "op_Decrement", "Decrement")]
+        public void ConsumeAbstractUnaryOperator_03(string prefixOp, string postfixOp, string metadataName, string opKind)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static T operator" + prefixOp + postfixOp + @" (T x);
+}
+
+class Test
+{
+    static T M02<T, U>(T x) where T : U where U : I1<T>
+    {
+        return " + prefixOp + "x" + postfixOp + @";
+    }
+
+    static T? M03<T, U>(T? y) where T : struct, U where U : I1<T>
+    {
+        return " + prefixOp + "y" + postfixOp + @";
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            switch ((prefixOp, postfixOp))
+            {
+                case ("++", ""):
+                case ("--", ""):
+                    verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       21 (0x15)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_000d:  dup
+  IL_000e:  starg.s    V_0
+  IL_0010:  stloc.0
+  IL_0011:  br.s       IL_0013
+  IL_0013:  ldloc.0
+  IL_0014:  ret
+}
+");
+                    verifier.VerifyIL("Test.M03<T, U>(T?)",
+@"
+{
+  // Code size       54 (0x36)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1,
+                T? V_2)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloca.s   V_0
+  IL_0005:  call       ""readonly bool T?.HasValue.get""
+  IL_000a:  brtrue.s   IL_0017
+  IL_000c:  ldloca.s   V_1
+  IL_000e:  initobj    ""T?""
+  IL_0014:  ldloc.1
+  IL_0015:  br.s       IL_002e
+  IL_0017:  ldloca.s   V_0
+  IL_0019:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001e:  constrained. ""T""
+  IL_0024:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_0029:  newobj     ""T?..ctor(T)""
+  IL_002e:  dup
+  IL_002f:  starg.s    V_0
+  IL_0031:  stloc.2
+  IL_0032:  br.s       IL_0034
+  IL_0034:  ldloc.2
+  IL_0035:  ret
+}
+");
+                    break;
+
+                case ("", "++"):
+                case ("", "--"):
+                    verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       21 (0x15)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  dup
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_000e:  starg.s    V_0
+  IL_0010:  stloc.0
+  IL_0011:  br.s       IL_0013
+  IL_0013:  ldloc.0
+  IL_0014:  ret
+}
+");
+                    verifier.VerifyIL("Test.M03<T, U>(T?)",
+@"
+{
+  // Code size       54 (0x36)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1,
+                T? V_2)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  dup
+  IL_0003:  stloc.0
+  IL_0004:  ldloca.s   V_0
+  IL_0006:  call       ""readonly bool T?.HasValue.get""
+  IL_000b:  brtrue.s   IL_0018
+  IL_000d:  ldloca.s   V_1
+  IL_000f:  initobj    ""T?""
+  IL_0015:  ldloc.1
+  IL_0016:  br.s       IL_002f
+  IL_0018:  ldloca.s   V_0
+  IL_001a:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001f:  constrained. ""T""
+  IL_0025:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_002a:  newobj     ""T?..ctor(T)""
+  IL_002f:  starg.s    V_0
+  IL_0031:  stloc.2
+  IL_0032:  br.s       IL_0034
+  IL_0034:  ldloc.2
+  IL_0035:  ret
+}
+");
+                    break;
+
+                default:
+                    verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  .locals init (T V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_000d:  stloc.0
+  IL_000e:  br.s       IL_0010
+  IL_0010:  ldloc.0
+  IL_0011:  ret
+}
+");
+                    verifier.VerifyIL("Test.M03<T, U>(T?)",
+@"
+{
+  // Code size       51 (0x33)
+  .maxstack  1
+  .locals init (T? V_0,
+                T? V_1,
+                T? V_2)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloca.s   V_0
+  IL_0005:  call       ""readonly bool T?.HasValue.get""
+  IL_000a:  brtrue.s   IL_0017
+  IL_000c:  ldloca.s   V_1
+  IL_000e:  initobj    ""T?""
+  IL_0014:  ldloc.1
+  IL_0015:  br.s       IL_002e
+  IL_0017:  ldloca.s   V_0
+  IL_0019:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001e:  constrained. ""T""
+  IL_0024:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_0029:  newobj     ""T?..ctor(T)""
+  IL_002e:  stloc.2
+  IL_002f:  br.s       IL_0031
+  IL_0031:  ldloc.2
+  IL_0032:  ret
+}
+");
+                    break;
+            }
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            switch ((prefixOp, postfixOp))
+            {
+                case ("++", ""):
+                case ("--", ""):
+                    verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_000c:  dup
+  IL_000d:  starg.s    V_0
+  IL_000f:  ret
+}
+");
+                    verifier.VerifyIL("Test.M03<T, U>(T?)",
+@"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloca.s   V_0
+  IL_0004:  call       ""readonly bool T?.HasValue.get""
+  IL_0009:  brtrue.s   IL_0016
+  IL_000b:  ldloca.s   V_1
+  IL_000d:  initobj    ""T?""
+  IL_0013:  ldloc.1
+  IL_0014:  br.s       IL_002d
+  IL_0016:  ldloca.s   V_0
+  IL_0018:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001d:  constrained. ""T""
+  IL_0023:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_0028:  newobj     ""T?..ctor(T)""
+  IL_002d:  dup
+  IL_002e:  starg.s    V_0
+  IL_0030:  ret
+}
+");
+                    break;
+
+                case ("", "++"):
+                case ("", "--"):
+                    verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  dup
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_000d:  starg.s    V_0
+  IL_000f:  ret
+}
+");
+                    verifier.VerifyIL("Test.M03<T, U>(T?)",
+@"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  dup
+  IL_0002:  stloc.0
+  IL_0003:  ldloca.s   V_0
+  IL_0005:  call       ""readonly bool T?.HasValue.get""
+  IL_000a:  brtrue.s   IL_0017
+  IL_000c:  ldloca.s   V_1
+  IL_000e:  initobj    ""T?""
+  IL_0014:  ldloc.1
+  IL_0015:  br.s       IL_002e
+  IL_0017:  ldloca.s   V_0
+  IL_0019:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001e:  constrained. ""T""
+  IL_0024:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_0029:  newobj     ""T?..ctor(T)""
+  IL_002e:  starg.s    V_0
+  IL_0030:  ret
+}
+");
+                    break;
+
+                default:
+                    verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       13 (0xd)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_000c:  ret
+}
+");
+                    verifier.VerifyIL("Test.M03<T, U>(T?)",
+@"
+{
+  // Code size       45 (0x2d)
+  .maxstack  1
+  .locals init (T? V_0,
+                T? V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloca.s   V_0
+  IL_0004:  call       ""readonly bool T?.HasValue.get""
+  IL_0009:  brtrue.s   IL_0015
+  IL_000b:  ldloca.s   V_1
+  IL_000d:  initobj    ""T?""
+  IL_0013:  ldloc.1
+  IL_0014:  ret
+  IL_0015:  ldloca.s   V_0
+  IL_0017:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001c:  constrained. ""T""
+  IL_0022:  call       ""T I1<T>." + metadataName + @"(T)""
+  IL_0027:  newobj     ""T?..ctor(T)""
+  IL_002c:  ret
+}
+");
+                    break;
+            }
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = postfixOp != "" ? (ExpressionSyntax)tree.GetRoot().DescendantNodes().OfType<PostfixUnaryExpressionSyntax>().First() : tree.GetRoot().DescendantNodes().OfType<PrefixUnaryExpressionSyntax>().First();
+
+            Assert.Equal(prefixOp + "x" + postfixOp, node.ToString());
+
+            switch ((prefixOp, postfixOp))
+            {
+                case ("++", ""):
+                case ("--", ""):
+                case ("", "++"):
+                case ("", "--"):
+                    VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IIncrementOrDecrementOperation (" + (prefixOp != "" ? "Prefix" : "Postfix") + @") (OperatorMethod: T I1<T>." + metadataName + @"(T x)) (OperationKind." + opKind + @", Type: T) (Syntax: '" + prefixOp + "x" + postfixOp + @"')
+  Target: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T) (Syntax: 'x')
+");
+                    break;
+
+                default:
+                    VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IUnaryOperation (UnaryOperatorKind." + opKind + @") (OperatorMethod: T I1<T>." + metadataName + @"(T x)) (OperationKind.Unary, Type: T) (Syntax: '" + prefixOp + "x" + postfixOp + @"')
+  Operand: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T) (Syntax: 'x')
+");
+                    break;
+            }
+        }
+
+        [Theory]
+        [InlineData("+", "")]
+        [InlineData("-", "")]
+        [InlineData("!", "")]
+        [InlineData("~", "")]
+        [InlineData("++", "")]
+        [InlineData("--", "")]
+        [InlineData("", "++")]
+        [InlineData("", "--")]
+        public void ConsumeAbstractUnaryOperator_04(string prefixOp, string postfixOp)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static T operator" + prefixOp + postfixOp + @" (T x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x) where T : I1<T>
+    {
+        _ = " + prefixOp + "x" + postfixOp + @";
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = -x;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, prefixOp + "x" + postfixOp).WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,32): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static T operator- (T x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, prefixOp + postfixOp).WithLocation(12, 31)
+                );
+        }
+
+        [Theory]
+        [InlineData("+", "")]
+        [InlineData("-", "")]
+        [InlineData("!", "")]
+        [InlineData("~", "")]
+        [InlineData("++", "")]
+        [InlineData("--", "")]
+        [InlineData("", "++")]
+        [InlineData("", "--")]
+        public void ConsumeAbstractUnaryOperator_06(string prefixOp, string postfixOp)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static T operator" + prefixOp + postfixOp + @" (T x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x) where T : I1<T>
+    {
+        _ = " + prefixOp + "x" + postfixOp + @";
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = -x;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, prefixOp + "x" + postfixOp).WithArguments("static abstract members in interfaces").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (12,31): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static T operator- (T x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, prefixOp + postfixOp).WithArguments("abstract", "9.0", "preview").WithLocation(12, 31)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractTrueOperator_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static bool operator true (I1 x);
+    abstract static bool operator false (I1 x);
+
+    static void M02(I1 x)
+    {
+        _ = x ? true : false;
+    }
+
+    void M03(I1 y)
+    {
+        _ = y ? true : false;
+    }
+}
+
+class Test
+{
+    static void MT1(I1 a)
+    {
+        _ = a ? true : false;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (b ? true : false).ToString());
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (9,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = x ? true : false;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "x").WithLocation(9, 13),
+                // (14,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = y ? true : false;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "y").WithLocation(14, 13),
+                // (22,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = a ? true : false;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "a").WithLocation(22, 13),
+                // (27,78): error CS8927: An expression tree may not contain an access of static abstract interface member
+                //         _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (b ? true : false).ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, "b").WithLocation(27, 78)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractTrueOperator_03()
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static bool operator true (T x);
+    abstract static bool operator false (T x);
+}
+
+class Test
+{
+    static void M02<T, U>(T x) where T : U where U : I1<T>
+    {
+        _ = x ? true : false;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""bool I1<T>.op_True(T)""
+  IL_000d:  brtrue.s   IL_0011
+  IL_000f:  br.s       IL_0011
+  IL_0011:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       14 (0xe)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""bool I1<T>.op_True(T)""
+  IL_000c:  pop
+  IL_000d:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<ConditionalExpressionSyntax>().First();
+
+            Assert.Equal("x ? true : false", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IConditionalOperation (OperationKind.Conditional, Type: System.Boolean) (Syntax: 'x ? true : false')
+  Condition: 
+    IUnaryOperation (UnaryOperatorKind.True) (OperatorMethod: System.Boolean I1<T>.op_True(T x)) (OperationKind.Unary, Type: System.Boolean, IsImplicit) (Syntax: 'x')
+      Operand: 
+        IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T) (Syntax: 'x')
+  WhenTrue: 
+    ILiteralOperation (OperationKind.Literal, Type: System.Boolean, Constant: True) (Syntax: 'true')
+  WhenFalse: 
+    ILiteralOperation (OperationKind.Literal, Type: System.Boolean, Constant: False) (Syntax: 'false')
+");
+        }
+
+        [Fact]
+        public void ConsumeAbstractTrueOperator_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool operator true (I1 x);
+    abstract static bool operator false (I1 x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x) where T : I1
+    {
+        _ = x ? true : false;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = x ? true : false;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "x").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static bool operator true (I1 x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "true").WithLocation(12, 35),
+                // (13,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static bool operator false (I1 x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "false").WithLocation(13, 35)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractTrueOperator_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool operator true (I1 x);
+    abstract static bool operator false (I1 x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x) where T : I1
+    {
+        _ = x ? true : false;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = x ? true : false;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x").WithArguments("static abstract members in interfaces").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (12,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool operator true (I1 x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "true").WithArguments("abstract", "9.0", "preview").WithLocation(12, 35),
+                // (13,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool operator false (I1 x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "false").WithArguments("abstract", "9.0", "preview").WithLocation(13, 35)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractTrueFalseOperatorForTupleEquality_01([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static bool operator true (I1 x);
+    abstract static bool operator false (I1 x);
+
+    static void M02((int, C<I1>) x)
+    {
+        _ = x " + op + @" x;
+    }
+
+    void M03((int, C<I1>) y)
+    {
+        _ = y " + op + @" y;
+    }
+}
+
+class Test
+{
+    static void MT1((int, C<I1>) a)
+    {
+        _ = a " + op + @" a;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = (System.Linq.Expressions.Expression<System.Action<(int, C<T>)>>)(((int, C<T>) b) => (b " + op + @" b).ToString());
+    }
+}
+
+#pragma warning disable CS0660 // 'C<T>' defines operator == or operator != but does not override Object.Equals(object o)
+#pragma warning disable CS0661 // 'C<T>' defines operator == or operator != but does not override Object.GetHashCode()
+
+class C<T>
+{
+    public static T operator == (C<T> x, C<T> y) => default;
+    public static T operator != (C<T> x, C<T> y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (9,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = x == x;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "x " + op + " x").WithLocation(9, 13),
+                // (14,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = y == y;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "y " + op + " y").WithLocation(14, 13),
+                // (22,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = a == a;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "a " + op + " a").WithLocation(22, 13),
+                // (27,98): error CS8382: An expression tree may not contain a tuple == or != operator
+                //         _ = (System.Linq.Expressions.Expression<System.Action<(int, C<T>)>>)(((int, C<T>) b) => (b == b).ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsTupleBinOp, "b " + op + " b").WithLocation(27, 98)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractTrueFalseOperatorForTupleEquality_03([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static bool operator true (T x);
+    abstract static bool operator false (T x);
+}
+
+class Test
+{
+    static void M02<T, U>((int, C<T>) x) where T : U where U : I1<T>
+    {
+        _ = x " + op + @" x;
+    }
+}
+
+#pragma warning disable CS0660 // 'C<T>' defines operator == or operator != but does not override Object.Equals(object o)
+#pragma warning disable CS0661 // 'C<T>' defines operator == or operator != but does not override Object.GetHashCode()
+
+class C<T>
+{
+    public static T operator == (C<T> x, C<T> y) => default;
+    public static T operator != (C<T> x, C<T> y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            if (op == "==")
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, C<T>>)",
+@"
+{
+  // Code size       55 (0x37)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, C<T>> V_0,
+                System.ValueTuple<int, C<T>> V_1)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldarg.0
+  IL_0004:  stloc.1
+  IL_0005:  ldloc.0
+  IL_0006:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_000b:  ldloc.1
+  IL_000c:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_0011:  bne.un.s   IL_0034
+  IL_0013:  ldloc.0
+  IL_0014:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_0019:  ldloc.1
+  IL_001a:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_001f:  call       ""T C<T>.op_Equality(C<T>, C<T>)""
+  IL_0024:  constrained. ""T""
+  IL_002a:  call       ""bool I1<T>.op_False(T)""
+  IL_002f:  ldc.i4.0
+  IL_0030:  ceq
+  IL_0032:  br.s       IL_0035
+  IL_0034:  ldc.i4.0
+  IL_0035:  pop
+  IL_0036:  ret
+}
+");
+            }
+            else
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, C<T>>)",
+@"
+{
+  // Code size       52 (0x34)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, C<T>> V_0,
+                System.ValueTuple<int, C<T>> V_1)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldarg.0
+  IL_0004:  stloc.1
+  IL_0005:  ldloc.0
+  IL_0006:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_000b:  ldloc.1
+  IL_000c:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_0011:  bne.un.s   IL_0031
+  IL_0013:  ldloc.0
+  IL_0014:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_0019:  ldloc.1
+  IL_001a:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_001f:  call       ""T C<T>.op_Inequality(C<T>, C<T>)""
+  IL_0024:  constrained. ""T""
+  IL_002a:  call       ""bool I1<T>.op_True(T)""
+  IL_002f:  br.s       IL_0032
+  IL_0031:  ldc.i4.1
+  IL_0032:  pop
+  IL_0033:  ret
+}
+");
+            }
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+
+            if (op == "==")
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, C<T>>)",
+@"
+{
+  // Code size       54 (0x36)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, C<T>> V_0,
+                System.ValueTuple<int, C<T>> V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldarg.0
+  IL_0003:  stloc.1
+  IL_0004:  ldloc.0
+  IL_0005:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_000a:  ldloc.1
+  IL_000b:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_0010:  bne.un.s   IL_0033
+  IL_0012:  ldloc.0
+  IL_0013:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_0018:  ldloc.1
+  IL_0019:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_001e:  call       ""T C<T>.op_Equality(C<T>, C<T>)""
+  IL_0023:  constrained. ""T""
+  IL_0029:  call       ""bool I1<T>.op_False(T)""
+  IL_002e:  ldc.i4.0
+  IL_002f:  ceq
+  IL_0031:  br.s       IL_0034
+  IL_0033:  ldc.i4.0
+  IL_0034:  pop
+  IL_0035:  ret
+}
+");
+            }
+            else
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, C<T>>)",
+@"
+{
+  // Code size       51 (0x33)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, C<T>> V_0,
+                System.ValueTuple<int, C<T>> V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldarg.0
+  IL_0003:  stloc.1
+  IL_0004:  ldloc.0
+  IL_0005:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_000a:  ldloc.1
+  IL_000b:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_0010:  bne.un.s   IL_0030
+  IL_0012:  ldloc.0
+  IL_0013:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_0018:  ldloc.1
+  IL_0019:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_001e:  call       ""T C<T>.op_Inequality(C<T>, C<T>)""
+  IL_0023:  constrained. ""T""
+  IL_0029:  call       ""bool I1<T>.op_True(T)""
+  IL_002e:  br.s       IL_0031
+  IL_0030:  ldc.i4.1
+  IL_0031:  pop
+  IL_0032:  ret
+}
+");
+            }
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().First();
+
+            Assert.Equal("x " + op + " x", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// Information about user-defined operators isn't exposed today.
+@"
+ITupleBinaryOperation (BinaryOperatorKind." + (op == "==" ? "Equals" : "NotEquals") + @") (OperationKind.TupleBinary, Type: System.Boolean) (Syntax: 'x " + op + @" x')
+  Left: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: (System.Int32, C<T>)) (Syntax: 'x')
+  Right: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: (System.Int32, C<T>)) (Syntax: 'x')
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractTrueFalseOperatorForTupleEquality_04([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool operator true (I1 x);
+    abstract static bool operator false (I1 x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>((int, C<T>) x) where T : I1
+    {
+        _ = x " + op + @" x;
+    }
+}
+
+#pragma warning disable CS0660 // 'C<T>' defines operator == or operator != but does not override Object.Equals(object o)
+#pragma warning disable CS0661 // 'C<T>' defines operator == or operator != but does not override Object.GetHashCode()
+
+class C<T>
+{
+    public static T operator == (C<T> x, C<T> y) => default;
+    public static T operator != (C<T> x, C<T> y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = x == x;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "x " + op + " x").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (21,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static bool operator true (I1 x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "true").WithLocation(21, 35),
+                // (22,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static bool operator false (I1 x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "false").WithLocation(22, 35)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractTrueFalseOperatorForTupleEquality_06([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool operator true (I1 x);
+    abstract static bool operator false (I1 x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>((int, C<T>) x) where T : I1
+    {
+        _ = x " + op + @" x;
+    }
+}
+
+#pragma warning disable CS0660 // 'C<T>' defines operator == or operator != but does not override Object.Equals(object o)
+#pragma warning disable CS0661 // 'C<T>' defines operator == or operator != but does not override Object.GetHashCode()
+
+class C<T>
+{
+    public static T operator == (C<T> x, C<T> y) => default;
+    public static T operator != (C<T> x, C<T> y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = x == x;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x " + op + " x").WithArguments("static abstract members in interfaces").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (21,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool operator true (I1 x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "true").WithArguments("abstract", "9.0", "preview").WithLocation(21, 35),
+                // (22,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool operator false (I1 x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "false").WithArguments("abstract", "9.0", "preview").WithLocation(22, 35)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractBinaryOperator_01([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            var source1 =
+@"
+partial interface I1
+{
+    abstract static I1 operator" + op + @" (I1 x, int y);
+
+    static void M02(I1 x)
+    {
+        _ = x " + op + @" 1;
+    }
+
+    void M03(I1 y)
+    {
+        _ = y " + op + @" 2;
+    }
+}
+
+class Test
+{
+    static void MT1(I1 a)
+    {
+        _ = a " + op + @" 3;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (b " + op + @" 4).ToString());
+    }
+}
+";
+
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1
+{
+    abstract static I1 operator" + matchingOp + @" (I1 x, int y);
+}
+";
+            }
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = x - 1;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "x " + op + " 1").WithLocation(8, 13),
+                // (13,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = y - 2;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "y " + op + " 2").WithLocation(13, 13),
+                // (21,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = a - 3;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "a " + op + " 3").WithLocation(21, 13),
+                // (26,78): error CS8927: An expression tree may not contain an access of static abstract interface member
+                //         _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (b - 4).ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, "b " + op + " 4").WithLocation(26, 78)
+                );
+        }
+
+        [Theory]
+        [InlineData("&", true, false, false, false)]
+        [InlineData("|", true, false, false, false)]
+        [InlineData("&", false, false, true, false)]
+        [InlineData("|", false, true, false, false)]
+        [InlineData("&", true, false, true, false)]
+        [InlineData("|", true, true, false, false)]
+        [InlineData("&", false, true, false, true)]
+        [InlineData("|", false, false, true, true)]
+        public void ConsumeAbstractLogicalBinaryOperator_01(string op, bool binaryIsAbstract, bool trueIsAbstract, bool falseIsAbstract, bool success)
+        {
+            var source1 =
+@"
+interface I1
+{
+    " + (binaryIsAbstract ? "abstract " : "") + @"static I1 operator" + op + @" (I1 x, I1 y)" + (binaryIsAbstract ? ";" : " => throw null;") + @"
+    " + (trueIsAbstract ? "abstract " : "") + @"static bool operator true (I1 x)" + (trueIsAbstract ? ";" : " => throw null;") + @"
+    " + (falseIsAbstract ? "abstract " : "") + @"static bool operator false (I1 x)" + (falseIsAbstract ? ";" : " => throw null;") + @"
+
+    static void M02(I1 x)
+    {
+        _ = x " + op + op + @" x;
+    }
+
+    void M03(I1 y)
+    {
+        _ = y " + op + op + @" y;
+    }
+}
+
+class Test
+{
+    static void MT1(I1 a)
+    {
+        _ = a " + op + op + @" a;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (b " + op + op + @" b).ToString());
+    }
+
+    static void MT3(I1 b, dynamic c)
+    {
+        _ = b " + op + op + @" c;
+    }
+";
+            if (!success)
+            {
+                source1 +=
+@"
+    static void MT4<T>() where T : I1
+    {
+        _ = (System.Linq.Expressions.Expression<System.Action<T, dynamic>>)((T d, dynamic e) => (d " + op + op + @" e).ToString());
+    }
+";
+            }
+
+            source1 +=
+@"
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreAppAndCSharp);
+
+            if (success)
+            {
+                Assert.False(binaryIsAbstract);
+                Assert.False(op == "&" ? falseIsAbstract : trueIsAbstract);
+                var binaryMetadataName = op == "&" ? "op_BitwiseAnd" : "op_BitwiseOr";
+                var unaryMetadataName = op == "&" ? "op_False" : "op_True";
+
+                var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+                verifier.VerifyIL("Test.MT1(I1)",
+@"
+{
+  // Code size       22 (0x16)
+  .maxstack  2
+  .locals init (I1 V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloc.0
+  IL_0004:  call       ""bool I1." + unaryMetadataName + @"(I1)""
+  IL_0009:  brtrue.s   IL_0015
+  IL_000b:  ldloc.0
+  IL_000c:  ldarg.0
+  IL_000d:  call       ""I1 I1." + binaryMetadataName + @"(I1, I1)""
+  IL_0012:  pop
+  IL_0013:  br.s       IL_0015
+  IL_0015:  ret
+}
+");
+
+                if (op == "&")
+                {
+                    verifier.VerifyIL("Test.MT3(I1, dynamic)",
+@"
+{
+  // Code size       97 (0x61)
+  .maxstack  8
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  call       ""bool I1.op_False(I1)""
+  IL_0007:  brtrue.s   IL_0060
+  IL_0009:  ldsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> Test.<>o__2.<>p__0""
+  IL_000e:  brfalse.s  IL_0012
+  IL_0010:  br.s       IL_0047
+  IL_0012:  ldc.i4.8
+  IL_0013:  ldc.i4.2
+  IL_0014:  ldtoken    ""Test""
+  IL_0019:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_001e:  ldc.i4.2
+  IL_001f:  newarr     ""Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo""
+  IL_0024:  dup
+  IL_0025:  ldc.i4.0
+  IL_0026:  ldc.i4.1
+  IL_0027:  ldnull
+  IL_0028:  call       ""Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags, string)""
+  IL_002d:  stelem.ref
+  IL_002e:  dup
+  IL_002f:  ldc.i4.1
+  IL_0030:  ldc.i4.0
+  IL_0031:  ldnull
+  IL_0032:  call       ""Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags, string)""
+  IL_0037:  stelem.ref
+  IL_0038:  call       ""System.Runtime.CompilerServices.CallSiteBinder Microsoft.CSharp.RuntimeBinder.Binder.BinaryOperation(Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags, System.Linq.Expressions.ExpressionType, System.Type, System.Collections.Generic.IEnumerable<Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo>)""
+  IL_003d:  call       ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>>.Create(System.Runtime.CompilerServices.CallSiteBinder)""
+  IL_0042:  stsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> Test.<>o__2.<>p__0""
+  IL_0047:  ldsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> Test.<>o__2.<>p__0""
+  IL_004c:  ldfld      ""System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic> System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>>.Target""
+  IL_0051:  ldsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> Test.<>o__2.<>p__0""
+  IL_0056:  ldarg.0
+  IL_0057:  ldarg.1
+  IL_0058:  callvirt   ""dynamic System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>.Invoke(System.Runtime.CompilerServices.CallSite, I1, dynamic)""
+  IL_005d:  pop
+  IL_005e:  br.s       IL_0060
+  IL_0060:  ret
+}
+");
+                }
+                else
+                {
+                    verifier.VerifyIL("Test.MT3(I1, dynamic)",
+@"
+{
+  // Code size       98 (0x62)
+  .maxstack  8
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  call       ""bool I1.op_True(I1)""
+  IL_0007:  brtrue.s   IL_0061
+  IL_0009:  ldsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> Test.<>o__2.<>p__0""
+  IL_000e:  brfalse.s  IL_0012
+  IL_0010:  br.s       IL_0048
+  IL_0012:  ldc.i4.8
+  IL_0013:  ldc.i4.s   36
+  IL_0015:  ldtoken    ""Test""
+  IL_001a:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_001f:  ldc.i4.2
+  IL_0020:  newarr     ""Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo""
+  IL_0025:  dup
+  IL_0026:  ldc.i4.0
+  IL_0027:  ldc.i4.1
+  IL_0028:  ldnull
+  IL_0029:  call       ""Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags, string)""
+  IL_002e:  stelem.ref
+  IL_002f:  dup
+  IL_0030:  ldc.i4.1
+  IL_0031:  ldc.i4.0
+  IL_0032:  ldnull
+  IL_0033:  call       ""Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags, string)""
+  IL_0038:  stelem.ref
+  IL_0039:  call       ""System.Runtime.CompilerServices.CallSiteBinder Microsoft.CSharp.RuntimeBinder.Binder.BinaryOperation(Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags, System.Linq.Expressions.ExpressionType, System.Type, System.Collections.Generic.IEnumerable<Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo>)""
+  IL_003e:  call       ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>>.Create(System.Runtime.CompilerServices.CallSiteBinder)""
+  IL_0043:  stsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> Test.<>o__2.<>p__0""
+  IL_0048:  ldsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> Test.<>o__2.<>p__0""
+  IL_004d:  ldfld      ""System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic> System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>>.Target""
+  IL_0052:  ldsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>> Test.<>o__2.<>p__0""
+  IL_0057:  ldarg.0
+  IL_0058:  ldarg.1
+  IL_0059:  callvirt   ""dynamic System.Func<System.Runtime.CompilerServices.CallSite, I1, dynamic, dynamic>.Invoke(System.Runtime.CompilerServices.CallSite, I1, dynamic)""
+  IL_005e:  pop
+  IL_005f:  br.s       IL_0061
+  IL_0061:  ret
+}
+");
+                }
+            }
+            else
+            {
+                var builder = ArrayBuilder<DiagnosticDescription>.GetInstance();
+
+                builder.AddRange(
+                    // (10,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                    //         _ = x && x;
+                    Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "x " + op + op + " x").WithLocation(10, 13),
+                    // (15,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                    //         _ = y && y;
+                    Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "y " + op + op + " y").WithLocation(15, 13),
+                    // (23,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                    //         _ = a && a;
+                    Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "a " + op + op + " a").WithLocation(23, 13),
+                    // (28,78): error CS8927: An expression tree may not contain an access of static abstract interface member
+                    //         _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (b && b).ToString());
+                    Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, "b " + op + op + " b").WithLocation(28, 78)
+                    );
+
+                if (op == "&" ? falseIsAbstract : trueIsAbstract)
+                {
+                    builder.Add(
+                        // (33,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                        //         _ = b || c;
+                        Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "b " + op + op + " c").WithLocation(33, 13)
+                        );
+                }
+
+                builder.Add(
+                    // (38,98): error CS7083: Expression must be implicitly convertible to Boolean or its type 'T' must define operator 'true'.
+                    //         _ = (System.Linq.Expressions.Expression<System.Action<T, dynamic>>)((T d, dynamic e) => (d || e).ToString());
+                    Diagnostic(ErrorCode.ERR_InvalidDynamicCondition, "d").WithArguments("T", op == "&" ? "false" : "true").WithLocation(38, 98)
+                    );
+
+                compilation1.VerifyDiagnostics(builder.ToArrayAndFree());
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractCompoundBinaryOperator_01([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>")] string op)
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static I1 operator" + op + @" (I1 x, int y);
+
+    static void M02(I1 x)
+    {
+        x " + op + @"= 1;
+    }
+
+    void M03(I1 y)
+    {
+        y " + op + @"= 2;
+    }
+}
+
+interface I2<T> where T : I2<T>
+{
+    abstract static T operator" + op + @" (T x, int y);
+}
+
+class Test
+{
+    static void MT1(I1 a)
+    {
+        a " + op + @"= 3;
+    }
+
+    static void MT2<T>() where T : I2<T>
+    {
+        _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (b " + op + @"= 4).ToString());
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         x /= 1;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "x " + op + "= 1").WithLocation(8, 9),
+                // (13,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         y /= 2;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "y " + op + "= 2").WithLocation(13, 9),
+                // (26,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         a /= 3;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "a " + op + "= 3").WithLocation(26, 9),
+                // (31,78): error CS0832: An expression tree may not contain an assignment operator
+                //         _ = (System.Linq.Expressions.Expression<System.Action<T>>)((T b) => (b /= 4).ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAssignment, "b " + op + "= 4").WithLocation(31, 78)
+                );
+        }
+
+        private static string BinaryOperatorKind(string op)
+        {
+            switch (op)
+            {
+                case "+":
+                    return "Add";
+
+                case "-":
+                    return "Subtract";
+
+                case "*":
+                    return "Multiply";
+
+                case "/":
+                    return "Divide";
+
+                case "%":
+                    return "Remainder";
+
+                case "<<":
+                    return "LeftShift";
+
+                case ">>":
+                    return "RightShift";
+
+                case "&":
+                    return "And";
+
+                case "|":
+                    return "Or";
+
+                case "^":
+                    return "ExclusiveOr";
+
+                case "<":
+                    return "LessThan";
+
+                case "<=":
+                    return "LessThanOrEqual";
+
+                case "==":
+                    return "Equals";
+
+                case "!=":
+                    return "NotEquals";
+
+                case ">=":
+                    return "GreaterThanOrEqual";
+
+                case ">":
+                    return "GreaterThan";
+
+            }
+
+            throw TestExceptionUtilities.UnexpectedValue(op);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractBinaryOperatorForTupleEquality_01([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+interface I1<T> where T : I1<T>
+{
+    abstract static bool operator == (T x, T y);
+    abstract static bool operator != (T x, T y);
+
+    abstract static bool operator == (I1<T> x, I1<T> y);
+    abstract static bool operator != (I1<T> x, I1<T> y);
+
+    static void M02((int, I1<T>) x)
+    {
+        _ = x " + op + @" x;
+    }
+
+    void M03((int, I1<T>) y)
+    {
+        _ = y " + op + @" y;
+    }
+}
+
+class Test
+{
+    static void MT1<T>((int, I1<T>) a) where T : I1<T>
+    {
+        _ = a " + op + @" a;
+    }
+
+    static void MT2<T>() where T : I1<T>
+    {
+        _ = (System.Linq.Expressions.Expression<System.Action<(int, T)>>)(((int, T) b) => (b " + op + @" b).ToString());
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (12,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = x == x;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "x " + op + " x").WithLocation(12, 13),
+                // (17,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = y == y;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "y " + op + " y").WithLocation(17, 13),
+                // (25,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = a == a;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "a " + op + " a").WithLocation(25, 13),
+                // (30,92): error CS8382: An expression tree may not contain a tuple == or != operator
+                //         _ = (System.Linq.Expressions.Expression<System.Action<(int, T)>>)(((int, T) b) => (b == b).ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsTupleBinOp, "b " + op + " b").WithLocation(30, 92)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractBinaryOperator_03([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>")] string op)
+        {
+            string metadataName = BinaryOperatorName(op);
+
+            bool isShiftOperator = op is "<<" or ">>";
+
+            var source1 =
+@"
+public partial interface I1<T0> where T0 : I1<T0>
+{
+    abstract static T0 operator" + op + @" (T0 x, int a);
+}
+
+partial class Test
+{
+    static void M03<T, U>(T x) where T : U where U : I1<T>
+    {
+        _ = x " + op + @" 1;
+    }
+
+    static void M05<T, U>(T? y) where T : struct, U where U : I1<T>
+    {
+        _ = y " + op + @" 1;
+    }
+}
+";
+
+            if (!isShiftOperator)
+            {
+                source1 += @"
+public partial interface I1<T0>
+{
+    abstract static T0 operator" + op + @" (int a, T0 x);
+    abstract static T0 operator" + op + @" (I1<T0> x, T0 a);
+    abstract static T0 operator" + op + @" (T0 x, I1<T0> a);
+}
+
+partial class Test
+{
+    static void M02<T, U>(T x) where T : U where U : I1<T>
+    {
+        _ = 1 " + op + @" x;
+    }
+
+    static void M04<T, U>(T? y) where T : struct, U where U : I1<T>
+    {
+        _ = 1 " + op + @" y;
+    }
+
+    static void M06<T, U>(I1<T> x, T y) where T : U where U : I1<T>
+    {
+        _ = x " + op + @" y;
+    }
+
+    static void M07<T, U>(T x, I1<T> y) where T : U where U : I1<T>
+    {
+        _ = x " + op + @" y;
+    }
+}
+";
+            }
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            if (!isShiftOperator)
+            {
+                verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldc.i4.1
+  IL_0002:  ldarg.0
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""T I1<T>." + metadataName + @"(int, T)""
+  IL_000e:  pop
+  IL_000f:  ret
+}
+");
+                verifier.VerifyIL("Test.M04<T, U>(T?)",
+@"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  .locals init (T? V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloca.s   V_0
+  IL_0005:  call       ""readonly bool T?.HasValue.get""
+  IL_000a:  brtrue.s   IL_000e
+  IL_000c:  br.s       IL_0022
+  IL_000e:  ldc.i4.1
+  IL_000f:  ldloca.s   V_0
+  IL_0011:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0016:  constrained. ""T""
+  IL_001c:  call       ""T I1<T>." + metadataName + @"(int, T)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+                verifier.VerifyIL("Test.M06<T, U>(I1<T>, T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldarg.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""T I1<T>." + metadataName + @"(I1<T>, T)""
+  IL_000e:  pop
+  IL_000f:  ret
+}
+");
+
+                verifier.VerifyIL("Test.M07<T, U>(T, I1<T>)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldarg.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""T I1<T>." + metadataName + @"(T, I1<T>)""
+  IL_000e:  pop
+  IL_000f:  ret
+}
+");
+            }
+
+            verifier.VerifyIL("Test.M03<T, U>(T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldc.i4.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""T I1<T>." + metadataName + @"(T, int)""
+  IL_000e:  pop
+  IL_000f:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M05<T, U>(T?)",
+@"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  .locals init (T? V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloca.s   V_0
+  IL_0005:  call       ""readonly bool T?.HasValue.get""
+  IL_000a:  brtrue.s   IL_000e
+  IL_000c:  br.s       IL_0022
+  IL_000e:  ldloca.s   V_0
+  IL_0010:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0015:  ldc.i4.1
+  IL_0016:  constrained. ""T""
+  IL_001c:  call       ""T I1<T>." + metadataName + @"(T, int)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            if (!isShiftOperator)
+            {
+                verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       15 (0xf)
+  .maxstack  2
+  IL_0000:  ldc.i4.1
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(int, T)""
+  IL_000d:  pop
+  IL_000e:  ret
+}
+");
+                verifier.VerifyIL("Test.M04<T, U>(T?)",
+@"
+{
+  // Code size       32 (0x20)
+  .maxstack  2
+  .locals init (T? V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloca.s   V_0
+  IL_0004:  call       ""readonly bool T?.HasValue.get""
+  IL_0009:  brfalse.s  IL_001f
+  IL_000b:  ldc.i4.1
+  IL_000c:  ldloca.s   V_0
+  IL_000e:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0013:  constrained. ""T""
+  IL_0019:  call       ""T I1<T>." + metadataName + @"(int, T)""
+  IL_001e:  pop
+  IL_001f:  ret
+}
+");
+                verifier.VerifyIL("Test.M06<T, U>(I1<T>, T)",
+@"
+{
+  // Code size       15 (0xf)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(I1<T>, T)""
+  IL_000d:  pop
+  IL_000e:  ret
+}
+");
+
+                verifier.VerifyIL("Test.M07<T, U>(T, I1<T>)",
+@"
+{
+  // Code size       15 (0xf)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(T, I1<T>)""
+  IL_000d:  pop
+  IL_000e:  ret
+}
+");
+            }
+
+            verifier.VerifyIL("Test.M03<T, U>(T)",
+@"
+{
+  // Code size       15 (0xf)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldc.i4.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(T, int)""
+  IL_000d:  pop
+  IL_000e:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M05<T, U>(T?)",
+@"
+{
+  // Code size       32 (0x20)
+  .maxstack  2
+  .locals init (T? V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloca.s   V_0
+  IL_0004:  call       ""readonly bool T?.HasValue.get""
+  IL_0009:  brfalse.s  IL_001f
+  IL_000b:  ldloca.s   V_0
+  IL_000d:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0012:  ldc.i4.1
+  IL_0013:  constrained. ""T""
+  IL_0019:  call       ""T I1<T>." + metadataName + @"(T, int)""
+  IL_001e:  pop
+  IL_001f:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Where(n => n.ToString() == "x " + op + " 1").Single();
+
+            Assert.Equal("x " + op + " 1", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IBinaryOperation (BinaryOperatorKind." + BinaryOperatorKind(op) + @") (OperatorMethod: T I1<T>." + metadataName + @"(T x, System.Int32 a)) (OperationKind.Binary, Type: T) (Syntax: 'x " + op + @" 1')
+  Left: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T) (Syntax: 'x')
+  Right: 
+    ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractComparisonBinaryOperator_03([CombinatorialValues("<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            string metadataName = BinaryOperatorName(op);
+
+            var source1 =
+@"
+public partial interface I1<T0> where T0 : I1<T0>
+{
+    abstract static bool operator" + op + @" (T0 x, int a);
+    abstract static bool operator" + op + @" (int a, T0 x);
+    abstract static bool operator" + op + @" (I1<T0> x, T0 a);
+    abstract static bool operator" + op + @" (T0 x, I1<T0> a);
+}
+
+partial class Test
+{
+    static void M02<T, U>(T x) where T : U where U : I1<T>
+    {
+        _ = 1 " + op + @" x;
+    }
+
+    static void M03<T, U>(T x) where T : U where U : I1<T>
+    {
+        _ = x " + op + @" 1;
+    }
+
+    static void M06<T, U>(I1<T> x, T y) where T : U where U : I1<T>
+    {
+        _ = x " + op + @" y;
+    }
+
+    static void M07<T, U>(T x, I1<T> y) where T : U where U : I1<T>
+    {
+        _ = x " + op + @" y;
+    }
+}
+";
+            string matchingOp = MatchingBinaryOperator(op);
+
+            source1 +=
+@"
+public partial interface I1<T0>
+{
+    abstract static bool operator" + matchingOp + @" (T0 x, int a);
+    abstract static bool operator" + matchingOp + @" (int a, T0 x);
+    abstract static bool operator" + matchingOp + @" (I1<T0> x, T0 a);
+    abstract static bool operator" + matchingOp + @" (T0 x, I1<T0> a);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldc.i4.1
+  IL_0002:  ldarg.0
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""bool I1<T>." + metadataName + @"(int, T)""
+  IL_000e:  pop
+  IL_000f:  ret
+}
+");
+            verifier.VerifyIL("Test.M06<T, U>(I1<T>, T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldarg.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""bool I1<T>." + metadataName + @"(I1<T>, T)""
+  IL_000e:  pop
+  IL_000f:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M07<T, U>(T, I1<T>)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldarg.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""bool I1<T>." + metadataName + @"(T, I1<T>)""
+  IL_000e:  pop
+  IL_000f:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M03<T, U>(T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldc.i4.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""bool I1<T>." + metadataName + @"(T, int)""
+  IL_000e:  pop
+  IL_000f:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       15 (0xf)
+  .maxstack  2
+  IL_0000:  ldc.i4.1
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""bool I1<T>." + metadataName + @"(int, T)""
+  IL_000d:  pop
+  IL_000e:  ret
+}
+");
+            verifier.VerifyIL("Test.M06<T, U>(I1<T>, T)",
+@"
+{
+  // Code size       15 (0xf)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""bool I1<T>." + metadataName + @"(I1<T>, T)""
+  IL_000d:  pop
+  IL_000e:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M07<T, U>(T, I1<T>)",
+@"
+{
+  // Code size       15 (0xf)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""bool I1<T>." + metadataName + @"(T, I1<T>)""
+  IL_000d:  pop
+  IL_000e:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M03<T, U>(T)",
+@"
+{
+  // Code size       15 (0xf)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldc.i4.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""bool I1<T>." + metadataName + @"(T, int)""
+  IL_000d:  pop
+  IL_000e:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Where(n => n.ToString() == "x " + op + " 1").Single();
+
+            Assert.Equal("x " + op + " 1", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IBinaryOperation (BinaryOperatorKind." + BinaryOperatorKind(op) + @") (OperatorMethod: System.Boolean I1<T>." + metadataName + @"(T x, System.Int32 a)) (OperationKind.Binary, Type: System.Boolean) (Syntax: 'x " + op + @" 1')
+  Left: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T) (Syntax: 'x')
+  Right: 
+    ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractLiftedComparisonBinaryOperator_03([CombinatorialValues("<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            string metadataName = BinaryOperatorName(op);
+
+            var source1 =
+@"
+public partial interface I1<T0> where T0 : I1<T0>
+{
+    abstract static bool operator" + op + @" (T0 x, T0 a);
+}
+
+partial class Test
+{
+    static void M04<T, U>(T? x, T? y) where T : struct, U where U : I1<T>
+    {
+        _ = x " + op + @" y;
+    }
+}
+";
+            string matchingOp = MatchingBinaryOperator(op);
+
+            source1 +=
+@"
+public partial interface I1<T0>
+{
+    abstract static bool operator" + matchingOp + @" (T0 x, T0 a);
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            if (op is "==" or "!=")
+            {
+                verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       61 (0x3d)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldarg.1
+  IL_0004:  stloc.1
+  IL_0005:  ldloca.s   V_0
+  IL_0007:  call       ""readonly bool T?.HasValue.get""
+  IL_000c:  ldloca.s   V_1
+  IL_000e:  call       ""readonly bool T?.HasValue.get""
+  IL_0013:  beq.s      IL_0017
+  IL_0015:  br.s       IL_003c
+  IL_0017:  ldloca.s   V_0
+  IL_0019:  call       ""readonly bool T?.HasValue.get""
+  IL_001e:  brtrue.s   IL_0022
+  IL_0020:  br.s       IL_003c
+  IL_0022:  ldloca.s   V_0
+  IL_0024:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0029:  ldloca.s   V_1
+  IL_002b:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0030:  constrained. ""T""
+  IL_0036:  call       ""bool I1<T>." + metadataName + @"(T, T)""
+  IL_003b:  pop
+  IL_003c:  ret
+}
+");
+            }
+            else
+            {
+                verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       51 (0x33)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldarg.1
+  IL_0004:  stloc.1
+  IL_0005:  ldloca.s   V_0
+  IL_0007:  call       ""readonly bool T?.HasValue.get""
+  IL_000c:  ldloca.s   V_1
+  IL_000e:  call       ""readonly bool T?.HasValue.get""
+  IL_0013:  and
+  IL_0014:  brtrue.s   IL_0018
+  IL_0016:  br.s       IL_0032
+  IL_0018:  ldloca.s   V_0
+  IL_001a:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001f:  ldloca.s   V_1
+  IL_0021:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0026:  constrained. ""T""
+  IL_002c:  call       ""bool I1<T>." + metadataName + @"(T, T)""
+  IL_0031:  pop
+  IL_0032:  ret
+}
+");
+            }
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            if (op is "==" or "!=")
+            {
+                verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       56 (0x38)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldarg.1
+  IL_0003:  stloc.1
+  IL_0004:  ldloca.s   V_0
+  IL_0006:  call       ""readonly bool T?.HasValue.get""
+  IL_000b:  ldloca.s   V_1
+  IL_000d:  call       ""readonly bool T?.HasValue.get""
+  IL_0012:  bne.un.s   IL_0037
+  IL_0014:  ldloca.s   V_0
+  IL_0016:  call       ""readonly bool T?.HasValue.get""
+  IL_001b:  brfalse.s  IL_0037
+  IL_001d:  ldloca.s   V_0
+  IL_001f:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0024:  ldloca.s   V_1
+  IL_0026:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_002b:  constrained. ""T""
+  IL_0031:  call       ""bool I1<T>." + metadataName + @"(T, T)""
+  IL_0036:  pop
+  IL_0037:  ret
+}
+");
+
+            }
+            else
+            {
+                verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       48 (0x30)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldarg.1
+  IL_0003:  stloc.1
+  IL_0004:  ldloca.s   V_0
+  IL_0006:  call       ""readonly bool T?.HasValue.get""
+  IL_000b:  ldloca.s   V_1
+  IL_000d:  call       ""readonly bool T?.HasValue.get""
+  IL_0012:  and
+  IL_0013:  brfalse.s  IL_002f
+  IL_0015:  ldloca.s   V_0
+  IL_0017:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001c:  ldloca.s   V_1
+  IL_001e:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0023:  constrained. ""T""
+  IL_0029:  call       ""bool I1<T>." + metadataName + @"(T, T)""
+  IL_002e:  pop
+  IL_002f:  ret
+}
+");
+            }
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Where(n => n.ToString() == "x " + op + " y").Single();
+
+            Assert.Equal("x " + op + " y", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IBinaryOperation (BinaryOperatorKind." + BinaryOperatorKind(op) + @", IsLifted) (OperatorMethod: System.Boolean I1<T>." + metadataName + @"(T x, T a)) (OperationKind.Binary, Type: System.Boolean) (Syntax: 'x " + op + @" y')
+  Left: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T?) (Syntax: 'x')
+  Right: 
+    IParameterReferenceOperation: y (OperationKind.ParameterReference, Type: T?) (Syntax: 'y')
+");
+        }
+
+        [Theory]
+        [InlineData("&", true, true)]
+        [InlineData("|", true, true)]
+        [InlineData("&", true, false)]
+        [InlineData("|", true, false)]
+        [InlineData("&", false, true)]
+        [InlineData("|", false, true)]
+        public void ConsumeAbstractLogicalBinaryOperator_03(string op, bool binaryIsAbstract, bool unaryIsAbstract)
+        {
+            var binaryMetadataName = op == "&" ? "op_BitwiseAnd" : "op_BitwiseOr";
+            var unaryMetadataName = op == "&" ? "op_False" : "op_True";
+            var opKind = op == "&" ? "ConditionalAnd" : "ConditionalOr";
+
+            if (binaryIsAbstract && unaryIsAbstract)
+            {
+                consumeAbstract(op);
+            }
+            else
+            {
+                consumeMixed(op, binaryIsAbstract, unaryIsAbstract);
+            }
+
+            void consumeAbstract(string op)
+            {
+                var source1 =
+@"
+public interface I1<T0> where T0 : I1<T0>
+{
+    abstract static T0 operator" + op + @" (T0 a, T0 x);
+    abstract static bool operator true (T0 x);
+    abstract static bool operator false (T0 x);
+}
+
+public interface I2<T0> where T0 : struct, I2<T0>
+{
+    abstract static T0 operator" + op + @" (T0 a, T0 x);
+    abstract static bool operator true (T0? x);
+    abstract static bool operator false (T0? x);
+}
+
+class Test
+{
+    static void M03<T, U>(T x, T y) where T : U where U : I1<T>
+    {
+        _ = x " + op + op + @" y;
+    }
+
+    static void M04<T, U>(T? x, T? y) where T : struct, U where U : I2<T>
+    {
+        _ = x " + op + op + @" y;
+    }
+}
+";
+                var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreAppAndCSharp);
+
+                var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+                verifier.VerifyIL("Test.M03<T, U>(T, T)",
+@"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloc.0
+  IL_0004:  constrained. ""T""
+  IL_000a:  call       ""bool I1<T>." + unaryMetadataName + @"(T)""
+  IL_000f:  brtrue.s   IL_0021
+  IL_0011:  ldloc.0
+  IL_0012:  ldarg.1
+  IL_0013:  constrained. ""T""
+  IL_0019:  call       ""T I1<T>." + binaryMetadataName + @"(T, T)""
+  IL_001e:  pop
+  IL_001f:  br.s       IL_0021
+  IL_0021:  ret
+}
+");
+                verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       69 (0x45)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1,
+                T? V_2)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloc.0
+  IL_0004:  constrained. ""T""
+  IL_000a:  call       ""bool I2<T>." + unaryMetadataName + @"(T?)""
+  IL_000f:  brtrue.s   IL_0044
+  IL_0011:  ldloc.0
+  IL_0012:  stloc.1
+  IL_0013:  ldarg.1
+  IL_0014:  stloc.2
+  IL_0015:  ldloca.s   V_1
+  IL_0017:  call       ""readonly bool T?.HasValue.get""
+  IL_001c:  ldloca.s   V_2
+  IL_001e:  call       ""readonly bool T?.HasValue.get""
+  IL_0023:  and
+  IL_0024:  brtrue.s   IL_0028
+  IL_0026:  br.s       IL_0042
+  IL_0028:  ldloca.s   V_1
+  IL_002a:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_002f:  ldloca.s   V_2
+  IL_0031:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0036:  constrained. ""T""
+  IL_003c:  call       ""T I2<T>." + binaryMetadataName + @"(T, T)""
+  IL_0041:  pop
+  IL_0042:  br.s       IL_0044
+  IL_0044:  ret
+}
+");
+
+                compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreAppAndCSharp);
+
+                verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+                verifier.VerifyIL("Test.M03<T, U>(T, T)",
+@"
+{
+  // Code size       31 (0x1f)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloc.0
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""bool I1<T>." + unaryMetadataName + @"(T)""
+  IL_000e:  brtrue.s   IL_001e
+  IL_0010:  ldloc.0
+  IL_0011:  ldarg.1
+  IL_0012:  constrained. ""T""
+  IL_0018:  call       ""T I1<T>." + binaryMetadataName + @"(T, T)""
+  IL_001d:  pop
+  IL_001e:  ret
+}
+");
+                verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       64 (0x40)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1,
+                T? V_2)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloc.0
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""bool I2<T>." + unaryMetadataName + @"(T?)""
+  IL_000e:  brtrue.s   IL_003f
+  IL_0010:  ldloc.0
+  IL_0011:  stloc.1
+  IL_0012:  ldarg.1
+  IL_0013:  stloc.2
+  IL_0014:  ldloca.s   V_1
+  IL_0016:  call       ""readonly bool T?.HasValue.get""
+  IL_001b:  ldloca.s   V_2
+  IL_001d:  call       ""readonly bool T?.HasValue.get""
+  IL_0022:  and
+  IL_0023:  brfalse.s  IL_003f
+  IL_0025:  ldloca.s   V_1
+  IL_0027:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_002c:  ldloca.s   V_2
+  IL_002e:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_0033:  constrained. ""T""
+  IL_0039:  call       ""T I2<T>." + binaryMetadataName + @"(T, T)""
+  IL_003e:  pop
+  IL_003f:  ret
+}
+");
+
+                var tree = compilation1.SyntaxTrees.Single();
+                var model = compilation1.GetSemanticModel(tree);
+                var node1 = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Where(n => n.ToString() == "x " + op + op + " y").First();
+
+                Assert.Equal("x " + op + op + " y", node1.ToString());
+
+                VerifyOperationTreeForNode(compilation1, model, node1,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IBinaryOperation (BinaryOperatorKind." + opKind + @") (OperatorMethod: T I1<T>." + binaryMetadataName + @"(T a, T x)) (OperationKind.Binary, Type: T) (Syntax: 'x " + op + op + @" y')
+  Left: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T) (Syntax: 'x')
+  Right: 
+    IParameterReferenceOperation: y (OperationKind.ParameterReference, Type: T) (Syntax: 'y')
+");
+            }
+
+            void consumeMixed(string op, bool binaryIsAbstract, bool unaryIsAbstract)
+            {
+                var source1 =
+@"
+public interface I1
+{
+    " + (binaryIsAbstract ? "abstract " : "") + @"static I1 operator" + op + @" (I1 a, I1 x)" + (binaryIsAbstract ? ";" : " => throw null;") + @"
+    " + (unaryIsAbstract ? "abstract " : "") + @"static bool operator true (I1 x)" + (unaryIsAbstract ? ";" : " => throw null;") + @"
+    " + (unaryIsAbstract ? "abstract " : "") + @"static bool operator false (I1 x)" + (unaryIsAbstract ? ";" : " => throw null;") + @"
+}
+
+class Test
+{
+    static void M03<T, U>(T x, T y) where T : U where U : I1
+    {
+        _ = x " + op + op + @" y;
+    }
+
+    static void M04<T, U>(T? x, T? y) where T : struct, U where U : I1
+    {
+        _ = x " + op + op + @" y;
+    }
+}
+";
+                var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreAppAndCSharp);
+
+                var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+                switch (binaryIsAbstract, unaryIsAbstract)
+                {
+                    case (true, false):
+                        verifier.VerifyIL("Test.M03<T, U>(T, T)",
+@"
+{
+  // Code size       38 (0x26)
+  .maxstack  2
+  .locals init (I1 V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  box        ""T""
+  IL_0007:  stloc.0
+  IL_0008:  ldloc.0
+  IL_0009:  call       ""bool I1." + unaryMetadataName + @"(I1)""
+  IL_000e:  brtrue.s   IL_0025
+  IL_0010:  ldloc.0
+  IL_0011:  ldarg.1
+  IL_0012:  box        ""T""
+  IL_0017:  constrained. ""T""
+  IL_001d:  call       ""I1 I1." + binaryMetadataName + @"(I1, I1)""
+  IL_0022:  pop
+  IL_0023:  br.s       IL_0025
+  IL_0025:  ret
+}
+");
+                        verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       38 (0x26)
+  .maxstack  2
+  .locals init (I1 V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  box        ""T?""
+  IL_0007:  stloc.0
+  IL_0008:  ldloc.0
+  IL_0009:  call       ""bool I1." + unaryMetadataName + @"(I1)""
+  IL_000e:  brtrue.s   IL_0025
+  IL_0010:  ldloc.0
+  IL_0011:  ldarg.1
+  IL_0012:  box        ""T?""
+  IL_0017:  constrained. ""T""
+  IL_001d:  call       ""I1 I1." + binaryMetadataName + @"(I1, I1)""
+  IL_0022:  pop
+  IL_0023:  br.s       IL_0025
+  IL_0025:  ret
+}
+");
+                        break;
+
+                    case (false, true):
+                        verifier.VerifyIL("Test.M03<T, U>(T, T)",
+@"
+{
+  // Code size       38 (0x26)
+  .maxstack  2
+  .locals init (I1 V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  box        ""T""
+  IL_0007:  stloc.0
+  IL_0008:  ldloc.0
+  IL_0009:  constrained. ""T""
+  IL_000f:  call       ""bool I1." + unaryMetadataName + @"(I1)""
+  IL_0014:  brtrue.s   IL_0025
+  IL_0016:  ldloc.0
+  IL_0017:  ldarg.1
+  IL_0018:  box        ""T""
+  IL_001d:  call       ""I1 I1." + binaryMetadataName + @"(I1, I1)""
+  IL_0022:  pop
+  IL_0023:  br.s       IL_0025
+  IL_0025:  ret
+}
+");
+                        verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       38 (0x26)
+  .maxstack  2
+  .locals init (I1 V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  box        ""T?""
+  IL_0007:  stloc.0
+  IL_0008:  ldloc.0
+  IL_0009:  constrained. ""T""
+  IL_000f:  call       ""bool I1." + unaryMetadataName + @"(I1)""
+  IL_0014:  brtrue.s   IL_0025
+  IL_0016:  ldloc.0
+  IL_0017:  ldarg.1
+  IL_0018:  box        ""T?""
+  IL_001d:  call       ""I1 I1." + binaryMetadataName + @"(I1, I1)""
+  IL_0022:  pop
+  IL_0023:  br.s       IL_0025
+  IL_0025:  ret
+}
+");
+                        break;
+
+                    default:
+                        Assert.True(false);
+                        break;
+                }
+
+                compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreAppAndCSharp);
+
+                verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+                switch (binaryIsAbstract, unaryIsAbstract)
+                {
+                    case (true, false):
+                        verifier.VerifyIL("Test.M03<T, U>(T, T)",
+@"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  .locals init (I1 V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  box        ""T""
+  IL_0006:  stloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  call       ""bool I1." + unaryMetadataName + @"(I1)""
+  IL_000d:  brtrue.s   IL_0022
+  IL_000f:  ldloc.0
+  IL_0010:  ldarg.1
+  IL_0011:  box        ""T""
+  IL_0016:  constrained. ""T""
+  IL_001c:  call       ""I1 I1." + binaryMetadataName + @"(I1, I1)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+                        verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  .locals init (I1 V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  box        ""T?""
+  IL_0006:  stloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  call       ""bool I1." + unaryMetadataName + @"(I1)""
+  IL_000d:  brtrue.s   IL_0022
+  IL_000f:  ldloc.0
+  IL_0010:  ldarg.1
+  IL_0011:  box        ""T?""
+  IL_0016:  constrained. ""T""
+  IL_001c:  call       ""I1 I1." + binaryMetadataName + @"(I1, I1)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+                        break;
+
+                    case (false, true):
+                        verifier.VerifyIL("Test.M03<T, U>(T, T)",
+@"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  .locals init (I1 V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  box        ""T""
+  IL_0006:  stloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  constrained. ""T""
+  IL_000e:  call       ""bool I1." + unaryMetadataName + @"(I1)""
+  IL_0013:  brtrue.s   IL_0022
+  IL_0015:  ldloc.0
+  IL_0016:  ldarg.1
+  IL_0017:  box        ""T""
+  IL_001c:  call       ""I1 I1." + binaryMetadataName + @"(I1, I1)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+                        verifier.VerifyIL("Test.M04<T, U>(T?, T?)",
+@"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  .locals init (I1 V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  box        ""T?""
+  IL_0006:  stloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  constrained. ""T""
+  IL_000e:  call       ""bool I1." + unaryMetadataName + @"(I1)""
+  IL_0013:  brtrue.s   IL_0022
+  IL_0015:  ldloc.0
+  IL_0016:  ldarg.1
+  IL_0017:  box        ""T?""
+  IL_001c:  call       ""I1 I1." + binaryMetadataName + @"(I1, I1)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+                        break;
+
+                    default:
+                        Assert.True(false);
+                        break;
+                }
+
+                var tree = compilation1.SyntaxTrees.Single();
+                var model = compilation1.GetSemanticModel(tree);
+                var node1 = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Where(n => n.ToString() == "x " + op + op + " y").First();
+
+                Assert.Equal("x " + op + op + " y", node1.ToString());
+
+                VerifyOperationTreeForNode(compilation1, model, node1,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IBinaryOperation (BinaryOperatorKind." + opKind + @") (OperatorMethod: I1 I1." + binaryMetadataName + @"(I1 a, I1 x)) (OperationKind.Binary, Type: I1) (Syntax: 'x " + op + op + @" y')
+  Left: 
+    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: I1, IsImplicit) (Syntax: 'x')
+      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+      Operand: 
+        IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T) (Syntax: 'x')
+  Right: 
+    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: I1, IsImplicit) (Syntax: 'y')
+      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+      Operand: 
+        IParameterReferenceOperation: y (OperationKind.ParameterReference, Type: T) (Syntax: 'y')
+");
+            }
+        }
+
+        [Theory]
+        [InlineData("+", "op_Addition", "Add")]
+        [InlineData("-", "op_Subtraction", "Subtract")]
+        [InlineData("*", "op_Multiply", "Multiply")]
+        [InlineData("/", "op_Division", "Divide")]
+        [InlineData("%", "op_Modulus", "Remainder")]
+        [InlineData("&", "op_BitwiseAnd", "And")]
+        [InlineData("|", "op_BitwiseOr", "Or")]
+        [InlineData("^", "op_ExclusiveOr", "ExclusiveOr")]
+        [InlineData("<<", "op_LeftShift", "LeftShift")]
+        [InlineData(">>", "op_RightShift", "RightShift")]
+        public void ConsumeAbstractCompoundBinaryOperator_03(string op, string metadataName, string operatorKind)
+        {
+            bool isShiftOperator = op.Length == 2;
+
+            var source1 =
+@"
+public interface I1<T0> where T0 : I1<T0>
+{
+";
+            if (!isShiftOperator)
+            {
+                source1 += @"
+    abstract static int operator" + op + @" (int a, T0 x);
+    abstract static I1<T0> operator" + op + @" (I1<T0> x, T0 a);
+    abstract static T0 operator" + op + @" (T0 x, I1<T0> a);
+";
+            }
+
+            source1 += @"
+    abstract static T0 operator" + op + @" (T0 x, int a);
+}
+
+class Test
+{
+";
+            if (!isShiftOperator)
+            {
+                source1 += @"
+    static void M02<T, U>(int a, T x) where T : U where U : I1<T>
+    {
+        a " + op + @"= x;
+    }
+
+    static void M04<T, U>(int? a, T? y) where T : struct, U where U : I1<T>
+    {
+        a " + op + @"= y;
+    }
+
+    static void M06<T, U>(I1<T> x, T y) where T : U where U : I1<T>
+    {
+        x " + op + @"= y;
+    }
+
+    static void M07<T, U>(T x, I1<T> y) where T : U where U : I1<T>
+    {
+        x " + op + @"= y;
+    }
+";
+            }
+
+            source1 += @"
+    static void M03<T, U>(T x) where T : U where U : I1<T>
+    {
+        x " + op + @"= 1;
+    }
+
+    static void M05<T, U>(T? y) where T : struct, U where U : I1<T>
+    {
+        y " + op + @"= 1;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            if (!isShiftOperator)
+            {
+                verifier.VerifyIL("Test.M02<T, U>(int, T)",
+@"
+{
+  // Code size       17 (0x11)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldarg.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""int I1<T>." + metadataName + @"(int, T)""
+  IL_000e:  starg.s    V_0
+  IL_0010:  ret
+}
+");
+                verifier.VerifyIL("Test.M04<T, U>(int?, T?)",
+@"
+{
+  // Code size       66 (0x42)
+  .maxstack  2
+  .locals init (int? V_0,
+                T? V_1,
+                int? V_2)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldarg.1
+  IL_0004:  stloc.1
+  IL_0005:  ldloca.s   V_0
+  IL_0007:  call       ""readonly bool int?.HasValue.get""
+  IL_000c:  ldloca.s   V_1
+  IL_000e:  call       ""readonly bool T?.HasValue.get""
+  IL_0013:  and
+  IL_0014:  brtrue.s   IL_0021
+  IL_0016:  ldloca.s   V_2
+  IL_0018:  initobj    ""int?""
+  IL_001e:  ldloc.2
+  IL_001f:  br.s       IL_003f
+  IL_0021:  ldloca.s   V_0
+  IL_0023:  call       ""readonly int int?.GetValueOrDefault()""
+  IL_0028:  ldloca.s   V_1
+  IL_002a:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_002f:  constrained. ""T""
+  IL_0035:  call       ""int I1<T>." + metadataName + @"(int, T)""
+  IL_003a:  newobj     ""int?..ctor(int)""
+  IL_003f:  starg.s    V_0
+  IL_0041:  ret
+}
+");
+                verifier.VerifyIL("Test.M06<T, U>(I1<T>, T)",
+@"
+{
+  // Code size       17 (0x11)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldarg.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""I1<T> I1<T>." + metadataName + @"(I1<T>, T)""
+  IL_000e:  starg.s    V_0
+  IL_0010:  ret
+}
+");
+
+                verifier.VerifyIL("Test.M07<T, U>(T, I1<T>)",
+@"
+{
+  // Code size       17 (0x11)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldarg.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""T I1<T>." + metadataName + @"(T, I1<T>)""
+  IL_000e:  starg.s    V_0
+  IL_0010:  ret
+}
+");
+            }
+
+            verifier.VerifyIL("Test.M03<T, U>(T)",
+@"
+{
+  // Code size       17 (0x11)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  ldc.i4.1
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""T I1<T>." + metadataName + @"(T, int)""
+  IL_000e:  starg.s    V_0
+  IL_0010:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M05<T, U>(T?)",
+@"
+{
+  // Code size       50 (0x32)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloca.s   V_0
+  IL_0005:  call       ""readonly bool T?.HasValue.get""
+  IL_000a:  brtrue.s   IL_0017
+  IL_000c:  ldloca.s   V_1
+  IL_000e:  initobj    ""T?""
+  IL_0014:  ldloc.1
+  IL_0015:  br.s       IL_002f
+  IL_0017:  ldloca.s   V_0
+  IL_0019:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001e:  ldc.i4.1
+  IL_001f:  constrained. ""T""
+  IL_0025:  call       ""T I1<T>." + metadataName + @"(T, int)""
+  IL_002a:  newobj     ""T?..ctor(T)""
+  IL_002f:  starg.s    V_0
+  IL_0031:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            if (!isShiftOperator)
+            {
+                verifier.VerifyIL("Test.M02<T, U>(int, T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""int I1<T>." + metadataName + @"(int, T)""
+  IL_000d:  starg.s    V_0
+  IL_000f:  ret
+}
+");
+                verifier.VerifyIL("Test.M04<T, U>(int?, T?)",
+@"
+{
+  // Code size       65 (0x41)
+  .maxstack  2
+  .locals init (int? V_0,
+                T? V_1,
+                int? V_2)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldarg.1
+  IL_0003:  stloc.1
+  IL_0004:  ldloca.s   V_0
+  IL_0006:  call       ""readonly bool int?.HasValue.get""
+  IL_000b:  ldloca.s   V_1
+  IL_000d:  call       ""readonly bool T?.HasValue.get""
+  IL_0012:  and
+  IL_0013:  brtrue.s   IL_0020
+  IL_0015:  ldloca.s   V_2
+  IL_0017:  initobj    ""int?""
+  IL_001d:  ldloc.2
+  IL_001e:  br.s       IL_003e
+  IL_0020:  ldloca.s   V_0
+  IL_0022:  call       ""readonly int int?.GetValueOrDefault()""
+  IL_0027:  ldloca.s   V_1
+  IL_0029:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_002e:  constrained. ""T""
+  IL_0034:  call       ""int I1<T>." + metadataName + @"(int, T)""
+  IL_0039:  newobj     ""int?..ctor(int)""
+  IL_003e:  starg.s    V_0
+  IL_0040:  ret
+}
+");
+                verifier.VerifyIL("Test.M06<T, U>(I1<T>, T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""I1<T> I1<T>." + metadataName + @"(I1<T>, T)""
+  IL_000d:  starg.s    V_0
+  IL_000f:  ret
+}
+");
+
+                verifier.VerifyIL("Test.M07<T, U>(T, I1<T>)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(T, I1<T>)""
+  IL_000d:  starg.s    V_0
+  IL_000f:  ret
+}
+");
+            }
+
+            verifier.VerifyIL("Test.M03<T, U>(T)",
+@"
+{
+  // Code size       16 (0x10)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldc.i4.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(T, int)""
+  IL_000d:  starg.s    V_0
+  IL_000f:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M05<T, U>(T?)",
+@"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  .locals init (T? V_0,
+                T? V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloca.s   V_0
+  IL_0004:  call       ""readonly bool T?.HasValue.get""
+  IL_0009:  brtrue.s   IL_0016
+  IL_000b:  ldloca.s   V_1
+  IL_000d:  initobj    ""T?""
+  IL_0013:  ldloc.1
+  IL_0014:  br.s       IL_002e
+  IL_0016:  ldloca.s   V_0
+  IL_0018:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001d:  ldc.i4.1
+  IL_001e:  constrained. ""T""
+  IL_0024:  call       ""T I1<T>." + metadataName + @"(T, int)""
+  IL_0029:  newobj     ""T?..ctor(T)""
+  IL_002e:  starg.s    V_0
+  IL_0030:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<AssignmentExpressionSyntax>().Where(n => n.ToString() == "x " + op + "= 1").Single();
+
+            Assert.Equal("x " + op + "= 1", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                               reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                               to expose this information? 
+@"
+ICompoundAssignmentOperation (BinaryOperatorKind." + operatorKind + @") (OperatorMethod: T I1<T>." + metadataName + @"(T x, System.Int32 a)) (OperationKind.CompoundAssignment, Type: T) (Syntax: 'x " + op + @"= 1')
+  InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+  OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+  Left: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T) (Syntax: 'x')
+  Right: 
+    ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractBinaryOperatorForTupleEquality_03([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static bool operator == (T x, T y);
+    abstract static bool operator != (T x, T y);
+}
+
+class Test
+{
+    static void M02<T, U>((int, T) x) where T : U where U : I1<T>
+    {
+        _ = x " + op + @" x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            if (op == "==")
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, T>)",
+@"
+{
+  // Code size       47 (0x2f)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, T> V_0,
+                System.ValueTuple<int, T> V_1)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldarg.0
+  IL_0004:  stloc.1
+  IL_0005:  ldloc.0
+  IL_0006:  ldfld      ""int System.ValueTuple<int, T>.Item1""
+  IL_000b:  ldloc.1
+  IL_000c:  ldfld      ""int System.ValueTuple<int, T>.Item1""
+  IL_0011:  bne.un.s   IL_002c
+  IL_0013:  ldloc.0
+  IL_0014:  ldfld      ""T System.ValueTuple<int, T>.Item2""
+  IL_0019:  ldloc.1
+  IL_001a:  ldfld      ""T System.ValueTuple<int, T>.Item2""
+  IL_001f:  constrained. ""T""
+  IL_0025:  call       ""bool I1<T>.op_Equality(T, T)""
+  IL_002a:  br.s       IL_002d
+  IL_002c:  ldc.i4.0
+  IL_002d:  pop
+  IL_002e:  ret
+}
+");
+            }
+            else
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, T>)",
+@"
+{
+  // Code size       47 (0x2f)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, T> V_0,
+                System.ValueTuple<int, T> V_1)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldarg.0
+  IL_0004:  stloc.1
+  IL_0005:  ldloc.0
+  IL_0006:  ldfld      ""int System.ValueTuple<int, T>.Item1""
+  IL_000b:  ldloc.1
+  IL_000c:  ldfld      ""int System.ValueTuple<int, T>.Item1""
+  IL_0011:  bne.un.s   IL_002c
+  IL_0013:  ldloc.0
+  IL_0014:  ldfld      ""T System.ValueTuple<int, T>.Item2""
+  IL_0019:  ldloc.1
+  IL_001a:  ldfld      ""T System.ValueTuple<int, T>.Item2""
+  IL_001f:  constrained. ""T""
+  IL_0025:  call       ""bool I1<T>.op_Inequality(T, T)""
+  IL_002a:  br.s       IL_002d
+  IL_002c:  ldc.i4.1
+  IL_002d:  pop
+  IL_002e:  ret
+}
+");
+            }
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+
+            if (op == "==")
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, T>)",
+@"
+{
+  // Code size       46 (0x2e)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, T> V_0,
+                System.ValueTuple<int, T> V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldarg.0
+  IL_0003:  stloc.1
+  IL_0004:  ldloc.0
+  IL_0005:  ldfld      ""int System.ValueTuple<int, T>.Item1""
+  IL_000a:  ldloc.1
+  IL_000b:  ldfld      ""int System.ValueTuple<int, T>.Item1""
+  IL_0010:  bne.un.s   IL_002b
+  IL_0012:  ldloc.0
+  IL_0013:  ldfld      ""T System.ValueTuple<int, T>.Item2""
+  IL_0018:  ldloc.1
+  IL_0019:  ldfld      ""T System.ValueTuple<int, T>.Item2""
+  IL_001e:  constrained. ""T""
+  IL_0024:  call       ""bool I1<T>.op_Equality(T, T)""
+  IL_0029:  br.s       IL_002c
+  IL_002b:  ldc.i4.0
+  IL_002c:  pop
+  IL_002d:  ret
+}
+");
+            }
+            else
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, T>)",
+@"
+{
+  // Code size       46 (0x2e)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, T> V_0,
+                System.ValueTuple<int, T> V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldarg.0
+  IL_0003:  stloc.1
+  IL_0004:  ldloc.0
+  IL_0005:  ldfld      ""int System.ValueTuple<int, T>.Item1""
+  IL_000a:  ldloc.1
+  IL_000b:  ldfld      ""int System.ValueTuple<int, T>.Item1""
+  IL_0010:  bne.un.s   IL_002b
+  IL_0012:  ldloc.0
+  IL_0013:  ldfld      ""T System.ValueTuple<int, T>.Item2""
+  IL_0018:  ldloc.1
+  IL_0019:  ldfld      ""T System.ValueTuple<int, T>.Item2""
+  IL_001e:  constrained. ""T""
+  IL_0024:  call       ""bool I1<T>.op_Inequality(T, T)""
+  IL_0029:  br.s       IL_002c
+  IL_002b:  ldc.i4.1
+  IL_002c:  pop
+  IL_002d:  ret
+}
+");
+            }
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().First();
+
+            Assert.Equal("x " + op + " x", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// Information about user-defined operators isn't exposed today.
+@"
+ITupleBinaryOperation (BinaryOperatorKind." + (op == "==" ? "Equals" : "NotEquals") + @") (OperationKind.TupleBinary, Type: System.Boolean) (Syntax: 'x " + op + @" x')
+  Left: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: (System.Int32, T)) (Syntax: 'x')
+  Right: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: (System.Int32, T)) (Syntax: 'x')
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractBinaryOperator_04([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator" + op + @" (I1 x, int y);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x, int y) where T : I1
+    {
+        _ = x " + op + @" y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = x - y;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "x " + op + " y").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_OperatorNeedsMatch).Verify(
+                // (12,32): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator- (I1 x, int y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(12, 32)
+                );
+        }
+
+        [Theory]
+        [InlineData("&", true, false, false, false)]
+        [InlineData("|", true, false, false, false)]
+        [InlineData("&", false, false, true, false)]
+        [InlineData("|", false, true, false, false)]
+        [InlineData("&", true, false, true, false)]
+        [InlineData("|", true, true, false, false)]
+        [InlineData("&", false, true, false, true)]
+        [InlineData("|", false, false, true, true)]
+        public void ConsumeAbstractLogicalBinaryOperator_04(string op, bool binaryIsAbstract, bool trueIsAbstract, bool falseIsAbstract, bool success)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    " + (binaryIsAbstract ? "abstract " : "") + @"static I1 operator" + op + @" (I1 x, I1 y)" + (binaryIsAbstract ? ";" : " => throw null;") + @"
+    " + (trueIsAbstract ? "abstract " : "") + @"static bool operator true (I1 x)" + (trueIsAbstract ? ";" : " => throw null;") + @"
+    " + (falseIsAbstract ? "abstract " : "") + @"static bool operator false (I1 x)" + (falseIsAbstract ? ";" : " => throw null;") + @"
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x, T y) where T : I1
+    {
+        _ = x " + op + op + @" y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreAppAndCSharp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            if (success)
+            {
+                compilation2.VerifyDiagnostics();
+            }
+            else
+            {
+                compilation2.VerifyDiagnostics(
+                    // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                    //         _ = x && y;
+                    Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "x " + op + op + " y").WithLocation(6, 13)
+                    );
+            }
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            var builder = ArrayBuilder<DiagnosticDescription>.GetInstance();
+
+            if (binaryIsAbstract)
+            {
+                builder.Add(
+                    // (12,32): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                    //     abstract static I1 operator& (I1 x, I1 y);
+                    Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(12, 32)
+                    );
+            }
+
+            if (trueIsAbstract)
+            {
+                builder.Add(
+                    // (13,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                    //     abstract static bool operator true (I1 x);
+                    Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "true").WithLocation(13, 35)
+                    );
+            }
+
+            if (falseIsAbstract)
+            {
+                builder.Add(
+                    // (14,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                    //     abstract static bool operator false (I1 x);
+                    Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "false").WithLocation(14, 35)
+                    );
+            }
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation).Verify(builder.ToArrayAndFree());
+        }
+
+        [Theory]
+        [InlineData("+")]
+        [InlineData("-")]
+        [InlineData("*")]
+        [InlineData("/")]
+        [InlineData("%")]
+        [InlineData("&")]
+        [InlineData("|")]
+        [InlineData("^")]
+        [InlineData("<<")]
+        [InlineData(">>")]
+        public void ConsumeAbstractCompoundBinaryOperator_04(string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static T operator" + op + @" (T x, int y);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x, int y) where T : I1<T>
+    {
+        x " + op + @"= y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         x *= y;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "x " + op + "= y").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,31): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static T operator* (T x, int y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(12, 31)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractBinaryOperatorForTupleEquality_04([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static bool operator == (T x, T y);
+    abstract static bool operator != (T x, T y);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>((int, T) x) where T : I1<T>
+    {
+        _ = x " + op + @" x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = x == x;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "x " + op + " x").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static bool operator == (T x, T y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "==").WithLocation(12, 35),
+                // (13,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static bool operator != (T x, T y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "!=").WithLocation(13, 35)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractBinaryOperator_06([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator" + op + @" (I1 x, int y);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x, int y) where T : I1
+    {
+        _ = x " + op + @" y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = x - y;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x " + op + " y").WithArguments("static abstract members in interfaces").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_OperatorNeedsMatch).Verify(
+                // (12,32): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static I1 operator- (I1 x, int y);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, op).WithArguments("abstract", "9.0", "preview").WithLocation(12, 32)
+                );
+        }
+
+        [Theory]
+        [InlineData("&", true, false, false, false)]
+        [InlineData("|", true, false, false, false)]
+        [InlineData("&", false, false, true, false)]
+        [InlineData("|", false, true, false, false)]
+        [InlineData("&", true, false, true, false)]
+        [InlineData("|", true, true, false, false)]
+        [InlineData("&", false, true, false, true)]
+        [InlineData("|", false, false, true, true)]
+        public void ConsumeAbstractLogicalBinaryOperator_06(string op, bool binaryIsAbstract, bool trueIsAbstract, bool falseIsAbstract, bool success)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    " + (binaryIsAbstract ? "abstract " : "") + @"static I1 operator" + op + @" (I1 x, I1 y)" + (binaryIsAbstract ? ";" : " => throw null;") + @"
+    " + (trueIsAbstract ? "abstract " : "") + @"static bool operator true (I1 x)" + (trueIsAbstract ? ";" : " => throw null;") + @"
+    " + (falseIsAbstract ? "abstract " : "") + @"static bool operator false (I1 x)" + (falseIsAbstract ? ";" : " => throw null;") + @"
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x, T y) where T : I1
+    {
+        _ = x " + op + op + @" y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreAppAndCSharp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            if (success)
+            {
+                compilation2.VerifyDiagnostics();
+            }
+            else
+            {
+                compilation2.VerifyDiagnostics(
+                    // (6,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    //         _ = x && y;
+                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "x " + op + op + " y").WithArguments("static abstract members in interfaces").WithLocation(6, 13)
+                    );
+            }
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var builder = ArrayBuilder<DiagnosticDescription>.GetInstance();
+
+            if (binaryIsAbstract)
+            {
+                builder.Add(
+                    // (12,32): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                    //     abstract static I1 operator& (I1 x, I1 y);
+                    Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, op).WithArguments("abstract", "9.0", "preview").WithLocation(12, 32)
+                    );
+            }
+
+            if (trueIsAbstract)
+            {
+                builder.Add(
+                    // (13,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                    //     abstract static bool operator true (I1 x);
+                    Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "true").WithArguments("abstract", "9.0", "preview").WithLocation(13, 35)
+                    );
+            }
+
+            if (falseIsAbstract)
+            {
+                builder.Add(
+                    // (14,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                    //     abstract static bool operator false (I1 x);
+                    Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "false").WithArguments("abstract", "9.0", "preview").WithLocation(14, 35)
+                    );
+            }
+
+            compilation3.VerifyDiagnostics(builder.ToArrayAndFree());
+        }
+
+        [Theory]
+        [InlineData("+")]
+        [InlineData("-")]
+        [InlineData("*")]
+        [InlineData("/")]
+        [InlineData("%")]
+        [InlineData("&")]
+        [InlineData("|")]
+        [InlineData("^")]
+        [InlineData("<<")]
+        [InlineData(">>")]
+        public void ConsumeAbstractCompoundBinaryOperator_06(string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static T operator" + op + @" (T x, int y);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>(T x, int y) where T : I1<T>
+    {
+        x " + op + @"= y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         x <<= y;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x " + op + "= y").WithArguments("static abstract members in interfaces").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (12,31): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static T operator<< (T x, int y);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, op).WithArguments("abstract", "9.0", "preview").WithLocation(12, 31)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractBinaryOperatorForTupleEquality_06([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static bool operator == (T x, T y);
+    abstract static bool operator != (T x, T y);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>((int, T) x) where T : I1<T>
+    {
+        _ = x " + op + @" x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = x == x;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x " + op + " x").WithArguments("static abstract members in interfaces").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (12,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool operator == (T x, T y);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "==").WithArguments("abstract", "9.0", "preview").WithLocation(12, 35),
+                // (13,35): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static bool operator != (T x, T y);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "!=").WithArguments("abstract", "9.0", "preview").WithLocation(13, 35)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertyGet_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static int P01 { get; set;}
+
+    static void M02()
+    {
+        _ = P01;
+        _ = P04;
+    }
+
+    void M03()
+    {
+        _ = this.P01;
+        _ = this.P04;
+    }
+
+    static int P04 { get; set; }
+
+    protected abstract static int P05 { get; set; }
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        _ = I1.P01;
+        _ = x.P01;
+        _ = I1.P04;
+        _ = x.P04;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = T.P03;
+        _ = T.P04;
+        _ = T.P00;
+        _ = T.P05;
+
+        _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01.ToString());
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = P01;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "P01").WithLocation(8, 13),
+                // (14,13): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = this.P01;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P01").WithArguments("I1.P01").WithLocation(14, 13),
+                // (15,13): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = this.P04;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P04").WithArguments("I1.P04").WithLocation(15, 13),
+                // (27,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = I1.P01;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "I1.P01").WithLocation(27, 13),
+                // (28,13): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = x.P01;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P01").WithArguments("I1.P01").WithLocation(28, 13),
+                // (30,13): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = x.P04;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P04").WithArguments("I1.P04").WithLocation(30, 13),
+                // (35,13): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = T.P03;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 13),
+                // (36,13): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = T.P04;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 13),
+                // (37,13): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = T.P00;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 13),
+                // (38,15): error CS0122: 'I1.P05' is inaccessible due to its protection level
+                //         _ = T.P05;
+                Diagnostic(ErrorCode.ERR_BadAccess, "P05").WithArguments("I1.P05").WithLocation(38, 15),
+                // (40,71): error CS8927: An expression tree may not contain an access of static abstract interface member
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01.ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, "T.P01").WithLocation(40, 71)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertySet_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static int P01 { get; set;}
+
+    static void M02()
+    {
+        P01 = 1;
+        P04 = 1;
+    }
+
+    void M03()
+    {
+        this.P01 = 1;
+        this.P04 = 1;
+    }
+
+    static int P04 { get; set; }
+
+    protected abstract static int P05 { get; set; }
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        I1.P01 = 1;
+        x.P01 = 1;
+        I1.P04 = 1;
+        x.P04 = 1;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        T.P03 = 1;
+        T.P04 = 1;
+        T.P00 = 1;
+        T.P05 = 1;
+
+        _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 = 1);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         P01 = 1;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "P01").WithLocation(8, 9),
+                // (14,9): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.P01 = 1;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P01").WithArguments("I1.P01").WithLocation(14, 9),
+                // (15,9): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.P04 = 1;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P04").WithArguments("I1.P04").WithLocation(15, 9),
+                // (27,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         I1.P01 = 1;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "I1.P01").WithLocation(27, 9),
+                // (28,9): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.P01 = 1;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P01").WithArguments("I1.P01").WithLocation(28, 9),
+                // (30,9): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.P04 = 1;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P04").WithArguments("I1.P04").WithLocation(30, 9),
+                // (35,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P03 = 1;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 9),
+                // (36,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P04 = 1;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 9),
+                // (37,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P00 = 1;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 9),
+                // (38,11): error CS0122: 'I1.P05' is inaccessible due to its protection level
+                //         T.P05 = 1;
+                Diagnostic(ErrorCode.ERR_BadAccess, "P05").WithArguments("I1.P05").WithLocation(38, 11),
+                // (40,71): error CS0832: An expression tree may not contain an assignment operator
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 = 1);
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAssignment, "T.P01 = 1").WithLocation(40, 71),
+                // (40,71): error CS8927: An expression tree may not contain an access of static abstract interface member
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 = 1);
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, "T.P01").WithLocation(40, 71)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertyCompound_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static int P01 { get; set;}
+
+    static void M02()
+    {
+        P01 += 1;
+        P04 += 1;
+    }
+
+    void M03()
+    {
+        this.P01 += 1;
+        this.P04 += 1;
+    }
+
+    static int P04 { get; set; }
+
+    protected abstract static int P05 { get; set; }
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        I1.P01 += 1;
+        x.P01 += 1;
+        I1.P04 += 1;
+        x.P04 += 1;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        T.P03 += 1;
+        T.P04 += 1;
+        T.P00 += 1;
+        T.P05 += 1;
+
+        _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 += 1);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         P01 += 1;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "P01").WithLocation(8, 9),
+                // (8,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         P01 += 1;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "P01").WithLocation(8, 9),
+                // (14,9): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.P01 += 1;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P01").WithArguments("I1.P01").WithLocation(14, 9),
+                // (15,9): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.P04 += 1;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P04").WithArguments("I1.P04").WithLocation(15, 9),
+                // (27,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         I1.P01 += 1;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "I1.P01").WithLocation(27, 9),
+                // (27,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         I1.P01 += 1;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "I1.P01").WithLocation(27, 9),
+                // (28,9): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.P01 += 1;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P01").WithArguments("I1.P01").WithLocation(28, 9),
+                // (30,9): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.P04 += 1;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P04").WithArguments("I1.P04").WithLocation(30, 9),
+                // (35,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P03 += 1;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 9),
+                // (36,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P04 += 1;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 9),
+                // (37,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P00 += 1;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 9),
+                // (38,11): error CS0122: 'I1.P05' is inaccessible due to its protection level
+                //         T.P05 += 1;
+                Diagnostic(ErrorCode.ERR_BadAccess, "P05").WithArguments("I1.P05").WithLocation(38, 11),
+                // (40,71): error CS0832: An expression tree may not contain an assignment operator
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 += 1);
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAssignment, "T.P01 += 1").WithLocation(40, 71),
+                // (40,71): error CS8927: An expression tree may not contain an access of static abstract interface member
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 += 1);
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, "T.P01").WithLocation(40, 71)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticProperty_02()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static int P01 { get; set; }
+
+    static void M02()
+    {
+        _ = nameof(P01);
+        _ = nameof(P04);
+    }
+
+    void M03()
+    {
+        _ = nameof(this.P01);
+        _ = nameof(this.P04);
+    }
+
+    static int P04 { get; set; }
+
+    protected abstract static int P05 { get; set; }
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        _ = nameof(I1.P01);
+        _ = nameof(x.P01);
+        _ = nameof(I1.P04);
+        _ = nameof(x.P04);
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = nameof(T.P03);
+        _ = nameof(T.P04);
+        _ = nameof(T.P00);
+        _ = nameof(T.P05);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (14,20): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = nameof(this.P01);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P01").WithArguments("I1.P01").WithLocation(14, 20),
+                // (15,20): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = nameof(this.P04);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P04").WithArguments("I1.P04").WithLocation(15, 20),
+                // (28,20): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = nameof(x.P01);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P01").WithArguments("I1.P01").WithLocation(28, 20),
+                // (30,20): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = nameof(x.P04);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P04").WithArguments("I1.P04").WithLocation(30, 20),
+                // (35,20): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = nameof(T.P03);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 20),
+                // (36,20): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = nameof(T.P04);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 20),
+                // (37,20): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = nameof(T.P00);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 20),
+                // (38,22): error CS0122: 'I1.P05' is inaccessible due to its protection level
+                //         _ = nameof(T.P05);
+                Diagnostic(ErrorCode.ERR_BadAccess, "P05").WithArguments("I1.P05").WithLocation(38, 22)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertyGet_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int P01 { get; set; }
+}
+
+class Test
+{
+    static void M02<T, U>() where T : U where U : I1
+    {
+        _ = T.P01;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       14 (0xe)
+  .maxstack  1
+  IL_0000:  nop
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""int I1.P01.get""
+  IL_000c:  pop
+  IL_000d:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       13 (0xd)
+  .maxstack  1
+  IL_0000:  constrained. ""T""
+  IL_0006:  call       ""int I1.P01.get""
+  IL_000b:  pop
+  IL_000c:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<AssignmentExpressionSyntax>().First().Right;
+
+            Assert.Equal("T.P01", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" qualifier is important for this invocation, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IPropertyReferenceOperation: System.Int32 I1.P01 { get; set; } (Static) (OperationKind.PropertyReference, Type: System.Int32) (Syntax: 'T.P01')
+  Instance Receiver: 
+    null
+");
+
+            var m02 = compilation1.GetMember<MethodSymbol>("Test.M02");
+
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString());
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString());
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+
+            Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()));
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertySet_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int P01 { get; set; }
+}
+
+class Test
+{
+    static void M02<T, U>() where T : U where U : I1
+    {
+        T.P01 = 1;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       15 (0xf)
+  .maxstack  1
+  IL_0000:  nop
+  IL_0001:  ldc.i4.1
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""void I1.P01.set""
+  IL_000d:  nop
+  IL_000e:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       13 (0xd)
+  .maxstack  1
+  IL_0000:  ldc.i4.1
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""void I1.P01.set""
+  IL_000c:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<AssignmentExpressionSyntax>().First().Left;
+
+            Assert.Equal("T.P01", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" qualifier is important for this invocation, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IPropertyReferenceOperation: System.Int32 I1.P01 { get; set; } (Static) (OperationKind.PropertyReference, Type: System.Int32) (Syntax: 'T.P01')
+  Instance Receiver: 
+    null
+");
+
+            var m02 = compilation1.GetMember<MethodSymbol>("Test.M02");
+
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString());
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString());
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+
+            Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()));
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertyCompound_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int P01 { get; set; }
+}
+
+class Test
+{
+    static void M02<T, U>() where T : U where U : I1
+    {
+        T.P01 += 1;
+    }
+
+    static string M03<T, U>() where T : U where U : I1
+    {
+        return nameof(T.P01);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       27 (0x1b)
+  .maxstack  2
+  IL_0000:  nop
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""int I1.P01.get""
+  IL_000c:  ldc.i4.1
+  IL_000d:  add
+  IL_000e:  constrained. ""T""
+  IL_0014:  call       ""void I1.P01.set""
+  IL_0019:  nop
+  IL_001a:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M03<T, U>()",
+@"
+{
+  // Code size       11 (0xb)
+  .maxstack  1
+  .locals init (string V_0)
+  IL_0000:  nop
+  IL_0001:  ldstr      ""P01""
+  IL_0006:  stloc.0
+  IL_0007:  br.s       IL_0009
+  IL_0009:  ldloc.0
+  IL_000a:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  constrained. ""T""
+  IL_0006:  call       ""int I1.P01.get""
+  IL_000b:  ldc.i4.1
+  IL_000c:  add
+  IL_000d:  constrained. ""T""
+  IL_0013:  call       ""void I1.P01.set""
+  IL_0018:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M03<T, U>()",
+@"
+{
+  // Code size        6 (0x6)
+  .maxstack  1
+  IL_0000:  ldstr      ""P01""
+  IL_0005:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<AssignmentExpressionSyntax>().First().Left;
+
+            Assert.Equal("T.P01", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" qualifier is important for this invocation, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IPropertyReferenceOperation: System.Int32 I1.P01 { get; set; } (Static) (OperationKind.PropertyReference, Type: System.Int32) (Syntax: 'T.P01')
+  Instance Receiver: 
+    null
+");
+
+            var m02 = compilation1.GetMember<MethodSymbol>("Test.M02");
+
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString());
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString());
+            Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+            Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+
+            Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()));
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertyGet_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int P01 { get; set; }
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        _ = T.P01;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = T.P01;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "T.P01").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,31): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "get").WithLocation(12, 31),
+                // (12,36): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "set").WithLocation(12, 36)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertySet_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int P01 { get; set; }
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.P01 = 1;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         T.P01 = 1;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "T.P01").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,31): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "get").WithLocation(12, 31),
+                // (12,36): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "set").WithLocation(12, 36)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertyCompound_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int P01 { get; set; }
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.P01 += 1;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         T.P01 += 1;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "T.P01").WithLocation(6, 9),
+                // (6,9): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         T.P01 += 1;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "T.P01").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,31): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "get").WithLocation(12, 31),
+                // (12,36): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "set").WithLocation(12, 36)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertyGet_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int P01 { get; set; }
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        _ = T.P01;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = T.P01;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (6,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = T.P01;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 13),
+                // (12,25): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P01").WithArguments("abstract", "9.0", "preview").WithLocation(12, 25)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertySet_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int P01 { get; set; }
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.P01 = 1;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.P01 = 1;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.P01 = 1;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9),
+                // (12,25): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P01").WithArguments("abstract", "9.0", "preview").WithLocation(12, 25)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticPropertyCompound_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int P01 { get; set; }
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.P01 += 1;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.P01 += 1;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.P01 += 1;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9),
+                // (12,25): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static int P01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P01").WithArguments("abstract", "9.0", "preview").WithLocation(12, 25)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticEventAdd_01()
+        {
+            var source1 =
+@"#pragma warning disable CS0067 // The event is never used
+interface I1
+{
+    abstract static event System.Action P01;
+
+    static void M02()
+    {
+        P01 += null;
+        P04 += null;
+    }
+
+    void M03()
+    {
+        this.P01 += null;
+        this.P04 += null;
+    }
+
+    static event System.Action P04;
+
+    protected abstract static event System.Action P05;
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        I1.P01 += null;
+        x.P01 += null;
+        I1.P04 += null;
+        x.P04 += null;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        T.P03 += null;
+        T.P04 += null;
+        T.P00 += null;
+        T.P05 += null;
+
+        _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 += null);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         P01 += null;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "P01 += null").WithLocation(8, 9),
+                // (14,9): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.P01 += null;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P01").WithArguments("I1.P01").WithLocation(14, 9),
+                // (14,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         this.P01 += null;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "this.P01 += null").WithLocation(14, 9),
+                // (15,9): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.P04 += null;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P04").WithArguments("I1.P04").WithLocation(15, 9),
+                // (27,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         I1.P01 += null;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "I1.P01 += null").WithLocation(27, 9),
+                // (28,9): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.P01 += null;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P01").WithArguments("I1.P01").WithLocation(28, 9),
+                // (28,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         x.P01 += null;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "x.P01 += null").WithLocation(28, 9),
+                // (30,9): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.P04 += null;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P04").WithArguments("I1.P04").WithLocation(30, 9),
+                // (35,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P03 += null;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 9),
+                // (36,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P04 += null;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 9),
+                // (37,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P00 += null;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 9),
+                // (38,11): error CS0122: 'I1.P05' is inaccessible due to its protection level
+                //         T.P05 += null;
+                Diagnostic(ErrorCode.ERR_BadAccess, "P05").WithArguments("I1.P05").WithLocation(38, 11),
+                // (40,71): error CS0832: An expression tree may not contain an assignment operator
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 += null);
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAssignment, "T.P01 += null").WithLocation(40, 71)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticEventRemove_01()
+        {
+            var source1 =
+@"#pragma warning disable CS0067 // The event is never used
+interface I1
+{
+    abstract static event System.Action P01;
+
+    static void M02()
+    {
+        P01 -= null;
+        P04 -= null;
+    }
+
+    void M03()
+    {
+        this.P01 -= null;
+        this.P04 -= null;
+    }
+
+    static event System.Action P04;
+
+    protected abstract static event System.Action P05;
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        I1.P01 -= null;
+        x.P01 -= null;
+        I1.P04 -= null;
+        x.P04 -= null;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        T.P03 -= null;
+        T.P04 -= null;
+        T.P00 -= null;
+        T.P05 -= null;
+
+        _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 -= null);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         P01 -= null;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "P01 -= null").WithLocation(8, 9),
+                // (14,9): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.P01 -= null;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P01").WithArguments("I1.P01").WithLocation(14, 9),
+                // (14,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         this.P01 -= null;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "this.P01 -= null").WithLocation(14, 9),
+                // (15,9): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         this.P04 -= null;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P04").WithArguments("I1.P04").WithLocation(15, 9),
+                // (27,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         I1.P01 -= null;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "I1.P01 -= null").WithLocation(27, 9),
+                // (28,9): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.P01 -= null;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P01").WithArguments("I1.P01").WithLocation(28, 9),
+                // (28,9): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         x.P01 -= null;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "x.P01 -= null").WithLocation(28, 9),
+                // (30,9): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         x.P04 -= null;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P04").WithArguments("I1.P04").WithLocation(30, 9),
+                // (35,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P03 -= null;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 9),
+                // (36,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P04 -= null;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 9),
+                // (37,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.P00 -= null;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 9),
+                // (38,11): error CS0122: 'I1.P05' is inaccessible due to its protection level
+                //         T.P05 -= null;
+                Diagnostic(ErrorCode.ERR_BadAccess, "P05").WithArguments("I1.P05").WithLocation(38, 11),
+                // (40,71): error CS0832: An expression tree may not contain an assignment operator
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => T.P01 -= null);
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAssignment, "T.P01 -= null").WithLocation(40, 71)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticEvent_02()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static event System.Action P01;
+
+    static void M02()
+    {
+        _ = nameof(P01);
+        _ = nameof(P04);
+    }
+
+    void M03()
+    {
+        _ = nameof(this.P01);
+        _ = nameof(this.P04);
+    }
+
+    static event System.Action P04;
+
+    protected abstract static event System.Action P05;
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        _ = nameof(I1.P01);
+        _ = nameof(x.P01);
+        _ = nameof(I1.P04);
+        _ = nameof(x.P04);
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = nameof(T.P03);
+        _ = nameof(T.P04);
+        _ = nameof(T.P00);
+        _ = nameof(T.P05);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (14,20): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = nameof(this.P01);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P01").WithArguments("I1.P01").WithLocation(14, 20),
+                // (15,20): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = nameof(this.P04);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.P04").WithArguments("I1.P04").WithLocation(15, 20),
+                // (28,20): error CS0176: Member 'I1.P01' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = nameof(x.P01);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P01").WithArguments("I1.P01").WithLocation(28, 20),
+                // (30,20): error CS0176: Member 'I1.P04' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = nameof(x.P04);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.P04").WithArguments("I1.P04").WithLocation(30, 20),
+                // (35,20): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = nameof(T.P03);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 20),
+                // (36,20): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = nameof(T.P04);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 20),
+                // (37,20): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = nameof(T.P00);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 20),
+                // (38,22): error CS0122: 'I1.P05' is inaccessible due to its protection level
+                //         _ = nameof(T.P05);
+                Diagnostic(ErrorCode.ERR_BadAccess, "P05").WithArguments("I1.P05").WithLocation(38, 22)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticEvent_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action E01;
+}
+
+class Test
+{
+    static void M02<T, U>() where T : U where U : I1
+    {
+        T.E01 += null;
+        T.E01 -= null;
+    }
+
+    static string M03<T, U>() where T : U where U : I1
+    {
+        return nameof(T.E01);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       28 (0x1c)
+  .maxstack  1
+  IL_0000:  nop
+  IL_0001:  ldnull
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""void I1.E01.add""
+  IL_000d:  nop
+  IL_000e:  ldnull
+  IL_000f:  constrained. ""T""
+  IL_0015:  call       ""void I1.E01.remove""
+  IL_001a:  nop
+  IL_001b:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M03<T, U>()",
+@"
+{
+  // Code size       11 (0xb)
+  .maxstack  1
+  .locals init (string V_0)
+  IL_0000:  nop
+  IL_0001:  ldstr      ""E01""
+  IL_0006:  stloc.0
+  IL_0007:  br.s       IL_0009
+  IL_0009:  ldloc.0
+  IL_000a:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       25 (0x19)
+  .maxstack  1
+  IL_0000:  ldnull
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""void I1.E01.add""
+  IL_000c:  ldnull
+  IL_000d:  constrained. ""T""
+  IL_0013:  call       ""void I1.E01.remove""
+  IL_0018:  ret
+}
+");
+
+            verifier.VerifyIL("Test.M03<T, U>()",
+@"
+{
+  // Code size        6 (0x6)
+  .maxstack  1
+  IL_0000:  ldstr      ""E01""
+  IL_0005:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<AssignmentExpressionSyntax>().First().Left;
+
+            Assert.Equal("T.E01", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" qualifier is important for this invocation, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IEventReferenceOperation: event System.Action I1.E01 (Static) (OperationKind.EventReference, Type: System.Action) (Syntax: 'T.E01')
+  Instance Receiver: 
+    null
+");
+
+            var m02 = compilation1.GetMember<MethodSymbol>("Test.M02");
+
+            Assert.Equal("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "E01").Single().ToTestDisplayString());
+            Assert.Equal("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "E01").Single().ToTestDisplayString());
+            Assert.Contains("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+            Assert.Contains("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings());
+
+            Assert.Equal("event System.Action I1.E01", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "E01").Single().ToTestDisplayString());
+            Assert.Equal("event System.Action I1.E01", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "E01").Single().ToTestDisplayString());
+            Assert.Contains("event System.Action I1.E01", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+            Assert.Contains("event System.Action I1.E01", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings());
+
+            Assert.Contains("E01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()));
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticEventAdd_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action P01;
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.P01 += null;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         T.P01 += null;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "T.P01 += null").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,41): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static event System.Action P01;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "P01").WithLocation(12, 41)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticEventRemove_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action P01;
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.P01 -= null;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         T.P01 -= null;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "T.P01 -= null").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,41): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static event System.Action P01;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "P01").WithLocation(12, 41)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticEventAdd_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action P01;
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.P01 += null;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.P01 += null;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.P01 += null;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9),
+                // (12,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static event System.Action P01;
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P01").WithArguments("abstract", "9.0", "preview").WithLocation(12, 41)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticEventRemove_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action P01;
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.P01 -= null;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.P01 -= null;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         T.P01 -= null;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 9),
+                // (12,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static event System.Action P01;
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P01").WithArguments("abstract", "9.0", "preview").WithLocation(12, 41)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticIndexedProperty_03()
+        {
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .custom instance void [mscorlib]System.Reflection.DefaultMemberAttribute::.ctor(string) = (
+        01 00 04 49 74 65 6d 00 00
+    )
+
+    // Methods
+    .method public hidebysig specialname newslot abstract virtual 
+        static int32 get_Item (
+            int32 x
+        ) cil managed 
+    {
+    } // end of method I1::get_Item
+
+    .method public hidebysig specialname newslot abstract virtual 
+        static void set_Item (
+            int32 x,
+            int32 'value'
+        ) cil managed 
+    {
+    } // end of method I1::set_Item
+
+    // Properties
+    .property int32 Item(
+        int32 x
+    )
+    {
+        .get int32 I1::get_Item(int32)
+        .set void I1::set_Item(int32, int32)
+    }
+
+} // end of class I1
+";
+
+            var source1 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.Item[0] += 1;
+    }
+
+    static string M03<T>() where T : I1
+    {
+        return nameof(T.Item);
+    }
+}
+";
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (6,9): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         T.Item[0] += 1;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(6, 9),
+                // (11,23): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         return nameof(T.Item);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(11, 23)
+                );
+
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T[0] += 1;
+    }
+
+    static void M03<T>() where T : I1
+    {
+        T.set_Item(0, T.get_Item(0) + 1);
+    }
+}
+";
+            var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation2.VerifyDiagnostics(
+                // (6,9): error CS0119: 'T' is a type, which is not valid in the given context
+                //         T[0] += 1;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type").WithLocation(6, 9),
+                // (11,11): error CS0571: 'I1.this[int].set': cannot explicitly call operator or accessor
+                //         T.set_Item(0, T.get_Item(0) + 1);
+                Diagnostic(ErrorCode.ERR_CantCallSpecialMethod, "set_Item").WithArguments("I1.this[int].set").WithLocation(11, 11),
+                // (11,25): error CS0571: 'I1.this[int].get': cannot explicitly call operator or accessor
+                //         T.set_Item(0, T.get_Item(0) + 1);
+                Diagnostic(ErrorCode.ERR_CantCallSpecialMethod, "get_Item").WithArguments("I1.this[int].get").WithLocation(11, 25)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticIndexedProperty_04()
+        {
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    // Methods
+    .method public hidebysig specialname newslot abstract virtual 
+        static int32 get_Item (
+            int32 x
+        ) cil managed 
+    {
+    } // end of method I1::get_Item
+
+    .method public hidebysig specialname newslot abstract virtual 
+        static void set_Item (
+            int32 x,
+            int32 'value'
+        ) cil managed 
+    {
+    } // end of method I1::set_Item
+
+    // Properties
+    .property int32 Item(
+        int32 x
+    )
+    {
+        .get int32 I1::get_Item(int32)
+        .set void I1::set_Item(int32, int32)
+    }
+
+} // end of class I1
+";
+
+            var source1 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.Item[0] += 1;
+    }
+
+    static string M03<T>() where T : I1
+    {
+        return nameof(T.Item);
+    }
+}
+";
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (6,11): error CS1545: Property, indexer, or event 'I1.Item[int]' is not supported by the language; try directly calling accessor methods 'I1.get_Item(int)' or 'I1.set_Item(int, int)'
+                //         T.Item[0] += 1;
+                Diagnostic(ErrorCode.ERR_BindToBogusProp2, "Item").WithArguments("I1.Item[int]", "I1.get_Item(int)", "I1.set_Item(int, int)").WithLocation(6, 11),
+                // (11,25): error CS1545: Property, indexer, or event 'I1.Item[int]' is not supported by the language; try directly calling accessor methods 'I1.get_Item(int)' or 'I1.set_Item(int, int)'
+                //         return nameof(T.Item);
+                Diagnostic(ErrorCode.ERR_BindToBogusProp2, "Item").WithArguments("I1.Item[int]", "I1.get_Item(int)", "I1.set_Item(int, int)").WithLocation(11, 25)
+                );
+
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        T.set_Item(0, T.get_Item(0) + 1);
+    }
+}
+";
+            var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation2, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T>()",
+@"
+{
+  // Code size       29 (0x1d)
+  .maxstack  3
+  IL_0000:  nop
+  IL_0001:  ldc.i4.0
+  IL_0002:  ldc.i4.0
+  IL_0003:  constrained. ""T""
+  IL_0009:  call       ""int I1.get_Item(int)""
+  IL_000e:  ldc.i4.1
+  IL_000f:  add
+  IL_0010:  constrained. ""T""
+  IL_0016:  call       ""void I1.set_Item(int, int)""
+  IL_001b:  nop
+  IL_001c:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_ConversionToDelegate_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static void M01();
+
+    static void M02()
+    {
+        _ = (System.Action)M01;
+        _ = (System.Action)M04;
+    }
+
+    void M03()
+    {
+        _ = (System.Action)this.M01;
+        _ = (System.Action)this.M04;
+    }
+
+    static void M04() {}
+
+    protected abstract static void M05();
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        _ = (System.Action)I1.M01;
+        _ = (System.Action)x.M01;
+        _ = (System.Action)I1.M04;
+        _ = (System.Action)x.M04;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = (System.Action)T.M03;
+        _ = (System.Action)T.M04;
+        _ = (System.Action)T.M00;
+        _ = (System.Action)T.M05;
+
+        _ = (System.Linq.Expressions.Expression<System.Action>)(() => ((System.Action)T.M01).ToString());
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = (System.Action)M01;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "(System.Action)M01").WithLocation(8, 13),
+                // (14,28): error CS0176: Member 'I1.M01()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = (System.Action)this.M01;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.M01").WithArguments("I1.M01()").WithLocation(14, 28),
+                // (15,28): error CS0176: Member 'I1.M04()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = (System.Action)this.M04;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.M04").WithArguments("I1.M04()").WithLocation(15, 28),
+                // (27,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = (System.Action)I1.M01;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "(System.Action)I1.M01").WithLocation(27, 13),
+                // (28,28): error CS0176: Member 'I1.M01()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = (System.Action)x.M01;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.M01").WithArguments("I1.M01()").WithLocation(28, 28),
+                // (30,28): error CS0176: Member 'I1.M04()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = (System.Action)x.M04;
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.M04").WithArguments("I1.M04()").WithLocation(30, 28),
+                // (35,28): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = (System.Action)T.M03;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 28),
+                // (36,28): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = (System.Action)T.M04;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 28),
+                // (37,28): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = (System.Action)T.M00;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 28),
+                // (38,30): error CS0122: 'I1.M05()' is inaccessible due to its protection level
+                //         _ = (System.Action)T.M05;
+                Diagnostic(ErrorCode.ERR_BadAccess, "M05").WithArguments("I1.M05()").WithLocation(38, 30),
+                // (40,87): error CS8927: An expression tree may not contain an access of static abstract interface member
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => ((System.Action)T.M01).ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, "T.M01").WithLocation(40, 87)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_ConversionToDelegate_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+class Test
+{
+    static System.Action M02<T, U>() where T : U where U : I1
+    {
+        return T.M01;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       24 (0x18)
+  .maxstack  2
+  .locals init (System.Action V_0)
+  IL_0000:  nop
+  IL_0001:  ldnull
+  IL_0002:  constrained. ""T""
+  IL_0008:  ldftn      ""void I1.M01()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stloc.0
+  IL_0014:  br.s       IL_0016
+  IL_0016:  ldloc.0
+  IL_0017:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       19 (0x13)
+  .maxstack  2
+  IL_0000:  ldnull
+  IL_0001:  constrained. ""T""
+  IL_0007:  ldftn      ""void I1.M01()""
+  IL_000d:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0012:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<MemberAccessExpressionSyntax>().First();
+
+            Assert.Equal("T.M01", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" qualifier is important for this invocation, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IMethodReferenceOperation: void I1.M01() (IsVirtual) (Static) (OperationKind.MethodReference, Type: null) (Syntax: 'T.M01')
+  Instance Receiver: 
+    null
+");
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_ConversionToDelegate_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        _ = (System.Action)T.M01;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = (System.Action)T.M01;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "(System.Action)T.M01").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,26): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(12, 26)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_ConversionToDelegate_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        _ = (System.Action)T.M01;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,28): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = (System.Action)T.M01;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 28)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (6,28): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = (System.Action)T.M01;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 28),
+                // (12,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(12, 26)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_DelegateCreation_01()
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static void M01();
+
+    static void M02()
+    {
+        _ = new System.Action(M01);
+        _ = new System.Action(M04);
+    }
+
+    void M03()
+    {
+        _ = new System.Action(this.M01);
+        _ = new System.Action(this.M04);
+    }
+
+    static void M04() {}
+
+    protected abstract static void M05();
+}
+
+class Test
+{
+    static void MT1(I1 x)
+    {
+        _ = new System.Action(I1.M01);
+        _ = new System.Action(x.M01);
+        _ = new System.Action(I1.M04);
+        _ = new System.Action(x.M04);
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = new System.Action(T.M03);
+        _ = new System.Action(T.M04);
+        _ = new System.Action(T.M00);
+        _ = new System.Action(T.M05);
+
+        _ = (System.Linq.Expressions.Expression<System.Action>)(() => new System.Action(T.M01).ToString());
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,31): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = new System.Action(M01);
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "M01").WithLocation(8, 31),
+                // (14,31): error CS0176: Member 'I1.M01()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = new System.Action(this.M01);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.M01").WithArguments("I1.M01()").WithLocation(14, 31),
+                // (15,31): error CS0176: Member 'I1.M04()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = new System.Action(this.M04);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "this.M04").WithArguments("I1.M04()").WithLocation(15, 31),
+                // (27,31): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = new System.Action(I1.M01);
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "I1.M01").WithLocation(27, 31),
+                // (28,31): error CS0176: Member 'I1.M01()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = new System.Action(x.M01);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.M01").WithArguments("I1.M01()").WithLocation(28, 31),
+                // (30,31): error CS0176: Member 'I1.M04()' cannot be accessed with an instance reference; qualify it with a type name instead
+                //         _ = new System.Action(x.M04);
+                Diagnostic(ErrorCode.ERR_ObjectProhibited, "x.M04").WithArguments("I1.M04()").WithLocation(30, 31),
+                // (35,31): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = new System.Action(T.M03);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 31),
+                // (36,31): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = new System.Action(T.M04);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 31),
+                // (37,31): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = new System.Action(T.M00);
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 31),
+                // (38,33): error CS0122: 'I1.M05()' is inaccessible due to its protection level
+                //         _ = new System.Action(T.M05);
+                Diagnostic(ErrorCode.ERR_BadAccess, "M05").WithArguments("I1.M05()").WithLocation(38, 33),
+                // (40,89): error CS8927: An expression tree may not contain an access of static abstract interface member
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => new System.Action(T.M01).ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, "T.M01").WithLocation(40, 89)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_DelegateCreation_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+class Test
+{
+    static System.Action M02<T, U>() where T : U where U : I1
+    {
+        return new System.Action(T.M01);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       24 (0x18)
+  .maxstack  2
+  .locals init (System.Action V_0)
+  IL_0000:  nop
+  IL_0001:  ldnull
+  IL_0002:  constrained. ""T""
+  IL_0008:  ldftn      ""void I1.M01()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stloc.0
+  IL_0014:  br.s       IL_0016
+  IL_0016:  ldloc.0
+  IL_0017:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       19 (0x13)
+  .maxstack  2
+  IL_0000:  ldnull
+  IL_0001:  constrained. ""T""
+  IL_0007:  ldftn      ""void I1.M01()""
+  IL_000d:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0012:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<MemberAccessExpressionSyntax>().First();
+
+            Assert.Equal("T.M01", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" qualifier is important for this invocation, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IMethodReferenceOperation: void I1.M01() (IsVirtual) (Static) (OperationKind.MethodReference, Type: null) (Syntax: 'T.M01')
+  Instance Receiver: 
+    null
+");
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_DelegateCreation_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        _ = new System.Action(T.M01);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,31): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = new System.Action(T.M01);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "T.M01").WithLocation(6, 31)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,26): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(12, 26)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_DelegateCreation_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>() where T : I1
+    {
+        _ = new System.Action(T.M01);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,31): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = new System.Action(T.M01);
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 31)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (6,31): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = new System.Action(T.M01);
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 31),
+                // (12,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(12, 26)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_ConversionToFunctionPointer_01()
+        {
+            var source1 =
+@"
+unsafe interface I1
+{
+    abstract static void M01();
+
+    static void M02()
+    {
+        _ = (delegate*<void>)&M01;
+        _ = (delegate*<void>)&M04;
+    }
+
+    void M03()
+    {
+        _ = (delegate*<void>)&this.M01;
+        _ = (delegate*<void>)&this.M04;
+    }
+
+    static void M04() {}
+
+    protected abstract static void M05();
+}
+
+unsafe class Test
+{
+    static void MT1(I1 x)
+    {
+        _ = (delegate*<void>)&I1.M01;
+        _ = (delegate*<void>)&x.M01;
+        _ = (delegate*<void>)&I1.M04;
+        _ = (delegate*<void>)&x.M04;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = (delegate*<void>)&T.M03;
+        _ = (delegate*<void>)&T.M04;
+        _ = (delegate*<void>)&T.M00;
+        _ = (delegate*<void>)&T.M05;
+
+        _ = (System.Linq.Expressions.Expression<System.Action>)(() => ((System.IntPtr)((delegate*<void>)&T.M01)).ToString());
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll.WithAllowUnsafe(true),
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = (delegate*<void>)&M01;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "(delegate*<void>)&M01").WithLocation(8, 13),
+                // (14,13): error CS8757: No overload for 'M01' matches function pointer 'delegate*<void>'
+                //         _ = (delegate*<void>)&this.M01;
+                Diagnostic(ErrorCode.ERR_MethFuncPtrMismatch, "(delegate*<void>)&this.M01").WithArguments("M01", "delegate*<void>").WithLocation(14, 13),
+                // (15,13): error CS8757: No overload for 'M04' matches function pointer 'delegate*<void>'
+                //         _ = (delegate*<void>)&this.M04;
+                Diagnostic(ErrorCode.ERR_MethFuncPtrMismatch, "(delegate*<void>)&this.M04").WithArguments("M04", "delegate*<void>").WithLocation(15, 13),
+                // (27,13): error CS8926: A static abstract interface member can be accessed only on a type parameter.
+                //         _ = (delegate*<void>)&I1.M01;
+                Diagnostic(ErrorCode.ERR_BadAbstractStaticMemberAccess, "(delegate*<void>)&I1.M01").WithLocation(27, 13),
+                // (28,13): error CS8757: No overload for 'M01' matches function pointer 'delegate*<void>'
+                //         _ = (delegate*<void>)&x.M01;
+                Diagnostic(ErrorCode.ERR_MethFuncPtrMismatch, "(delegate*<void>)&x.M01").WithArguments("M01", "delegate*<void>").WithLocation(28, 13),
+                // (30,13): error CS8757: No overload for 'M04' matches function pointer 'delegate*<void>'
+                //         _ = (delegate*<void>)&x.M04;
+                Diagnostic(ErrorCode.ERR_MethFuncPtrMismatch, "(delegate*<void>)&x.M04").WithArguments("M04", "delegate*<void>").WithLocation(30, 13),
+                // (35,31): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = (delegate*<void>)&T.M03;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(35, 31),
+                // (36,31): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = (delegate*<void>)&T.M04;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(36, 31),
+                // (37,31): error CS0119: 'T' is a type parameter, which is not valid in the given context
+                //         _ = (delegate*<void>)&T.M00;
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "T").WithArguments("T", "type parameter").WithLocation(37, 31),
+                // (38,33): error CS0122: 'I1.M05()' is inaccessible due to its protection level
+                //         _ = (delegate*<void>)&T.M05;
+                Diagnostic(ErrorCode.ERR_BadAccess, "M05").WithArguments("I1.M05()").WithLocation(38, 33),
+                // (40,88): error CS1944: An expression tree may not contain an unsafe pointer operation
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => ((System.IntPtr)((delegate*<void>)&T.M01)).ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsPointerOp, "(delegate*<void>)&T.M01").WithLocation(40, 88),
+                // (40,106): error CS8810: '&' on method groups cannot be used in expression trees
+                //         _ = (System.Linq.Expressions.Expression<System.Action>)(() => ((System.IntPtr)((delegate*<void>)&T.M01)).ToString());
+                Diagnostic(ErrorCode.ERR_AddressOfMethodGroupInExpressionTree, "T.M01").WithLocation(40, 106)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_ConversionToFunctionPointer_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+unsafe class Test
+{
+    static delegate*<void> M02<T, U>() where T : U where U : I1
+    {
+        return &T.M01;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll.WithAllowUnsafe(true),
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  .locals init (delegate*<void> V_0)
+  IL_0000:  nop
+  IL_0001:  constrained. ""T""
+  IL_0007:  ldftn      ""void I1.M01()""
+  IL_000d:  stloc.0
+  IL_000e:  br.s       IL_0010
+  IL_0010:  ldloc.0
+  IL_0011:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll.WithAllowUnsafe(true),
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>()",
+@"
+{
+  // Code size       13 (0xd)
+  .maxstack  1
+  IL_0000:  constrained. ""T""
+  IL_0006:  ldftn      ""void I1.M01()""
+  IL_000c:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<MemberAccessExpressionSyntax>().First();
+
+            Assert.Equal("T.M01", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" qualifier is important for this invocation, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IMethodReferenceOperation: void I1.M01() (IsVirtual) (Static) (OperationKind.MethodReference, Type: null) (Syntax: 'T.M01')
+  Instance Receiver: 
+    null
+");
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_ConversionFunctionPointer_04()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+@"
+unsafe class Test
+{
+    static void M02<T>() where T : I1
+    {
+        _ = (delegate*<void>)&T.M01;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll.WithAllowUnsafe(true),
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = (delegate*<void>)&T.M01;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "(delegate*<void>)&T.M01").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll.WithAllowUnsafe(true),
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (12,26): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(12, 26)
+                );
+        }
+
+        [Fact]
+        public void ConsumeAbstractStaticMethod_ConversionToFunctionPointer_06()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+@"
+unsafe class Test
+{
+    static void M02<T>() where T : I1
+    {
+        _ = (delegate*<void>)&T.M01;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll.WithAllowUnsafe(true),
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,31): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = (delegate*<void>)&T.M01;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 31)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll.WithAllowUnsafe(true),
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (6,31): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = (delegate*<void>)&T.M01;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "T").WithArguments("static abstract members in interfaces").WithLocation(6, 31),
+                // (12,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(12, 26)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_01(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+" + typeKeyword + @"
+    C1 : I1
+{}
+
+" + typeKeyword + @"
+    C2 : I1
+{
+    public void M01() {}
+}
+
+" + typeKeyword + @"
+    C3 : I1
+{
+    static void M01() {}
+}
+
+" + typeKeyword + @"
+    C4 : I1
+{
+    void I1.M01() {}
+}
+
+" + typeKeyword + @"
+    C5 : I1
+{
+    public static int M01() => throw null;
+}
+
+" + typeKeyword + @"
+    C6 : I1
+{
+    static int I1.M01() => throw null;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,10): error CS0535: 'C1' does not implement interface member 'I1.M01()'
+                //     C1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01()").WithLocation(8, 10),
+                // (12,10): error CS8928: 'C2' does not implement static interface member 'I1.M01()'. 'C2.M01()' cannot implement the interface member because it is not static.
+                //     C2 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotStatic, "I1").WithArguments("C2", "I1.M01()", "C2.M01()").WithLocation(12, 10),
+                // (18,10): error CS0737: 'C3' does not implement interface member 'I1.M01()'. 'C3.M01()' cannot implement an interface member because it is not public.
+                //     C3 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "I1").WithArguments("C3", "I1.M01()", "C3.M01()").WithLocation(18, 10),
+                // (24,10): error CS0535: 'C4' does not implement interface member 'I1.M01()'
+                //     C4 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C4", "I1.M01()").WithLocation(24, 10),
+                // (26,13): error CS0539: 'C4.M01()' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C4.M01()").WithLocation(26, 13),
+                // (30,10): error CS0738: 'C5' does not implement interface member 'I1.M01()'. 'C5.M01()' cannot implement 'I1.M01()' because it does not have the matching return type of 'void'.
+                //     C5 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("C5", "I1.M01()", "C5.M01()", "void").WithLocation(30, 10),
+                // (36,10): error CS0535: 'C6' does not implement interface member 'I1.M01()'
+                //     C6 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C6", "I1.M01()").WithLocation(36, 10),
+                // (38,19): error CS0539: 'C6.M01()' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static int I1.M01() => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C6.M01()").WithLocation(38, 19)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_02(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract void M01();
+}
+
+" + typeKeyword + @"
+    C1 : I1
+{}
+
+" + typeKeyword + @"
+    C2 : I1
+{
+    public static void M01() {}
+}
+
+" + typeKeyword + @"
+    C3 : I1
+{
+    void M01() {}
+}
+
+" + typeKeyword + @"
+    C4 : I1
+{
+    static void I1.M01() {}
+}
+
+" + typeKeyword + @"
+    C5 : I1
+{
+    public int M01() => throw null;
+}
+
+" + typeKeyword + @"
+    C6 : I1
+{
+    int I1.M01() => throw null;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,10): error CS0535: 'C1' does not implement interface member 'I1.M01()'
+                //     C1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01()").WithLocation(8, 10),
+                // (12,10): error CS0736: 'C2' does not implement instance interface member 'I1.M01()'. 'C2.M01()' cannot implement the interface member because it is static.
+                //     C2 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "I1").WithArguments("C2", "I1.M01()", "C2.M01()").WithLocation(12, 10),
+                // (18,10): error CS0737: 'C3' does not implement interface member 'I1.M01()'. 'C3.M01()' cannot implement an interface member because it is not public.
+                //     C3 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "I1").WithArguments("C3", "I1.M01()", "C3.M01()").WithLocation(18, 10),
+                // (24,10): error CS0535: 'C4' does not implement interface member 'I1.M01()'
+                //     C4 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C4", "I1.M01()").WithLocation(24, 10),
+                // (26,20): error CS0539: 'C4.M01()' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C4.M01()").WithLocation(26, 20),
+                // (30,10): error CS0738: 'C5' does not implement interface member 'I1.M01()'. 'C5.M01()' cannot implement 'I1.M01()' because it does not have the matching return type of 'void'.
+                //     C5 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("C5", "I1.M01()", "C5.M01()", "void").WithLocation(30, 10),
+                // (36,10): error CS0535: 'C6' does not implement interface member 'I1.M01()'
+                //     C6 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C6", "I1.M01()").WithLocation(36, 10),
+                // (38,12): error CS0539: 'C6.M01()' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     int I1.M01() => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C6.M01()").WithLocation(38, 12)
+                );
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticMethod_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+interface I2 : I1
+{}
+
+interface I3 : I1
+{
+    public virtual void M01() {}
+}
+
+interface I4 : I1
+{
+    static void M01() {}
+}
+
+interface I5 : I1
+{
+    void I1.M01() {}
+}
+
+interface I6 : I1
+{
+    static void I1.M01() {}
+}
+
+interface I7 : I1
+{
+    abstract static void M01();
+}
+
+interface I8 : I1
+{
+    abstract static void I1.M01();
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (12,25): warning CS0108: 'I3.M01()' hides inherited member 'I1.M01()'. Use the new keyword if hiding was intended.
+                //     public virtual void M01() {}
+                Diagnostic(ErrorCode.WRN_NewRequired, "M01").WithArguments("I3.M01()", "I1.M01()").WithLocation(12, 25),
+                // (17,17): warning CS0108: 'I4.M01()' hides inherited member 'I1.M01()'. Use the new keyword if hiding was intended.
+                //     static void M01() {}
+                Diagnostic(ErrorCode.WRN_NewRequired, "M01").WithArguments("I4.M01()", "I1.M01()").WithLocation(17, 17),
+                // (22,13): error CS0539: 'I5.M01()' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("I5.M01()").WithLocation(22, 13),
+                // (27,20): error CS0106: The modifier 'static' is not valid for this item
+                //     static void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M01").WithArguments("static").WithLocation(27, 20),
+                // (27,20): error CS0539: 'I6.M01()' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("I6.M01()").WithLocation(27, 20),
+                // (32,26): warning CS0108: 'I7.M01()' hides inherited member 'I1.M01()'. Use the new keyword if hiding was intended.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.WRN_NewRequired, "M01").WithArguments("I7.M01()", "I1.M01()").WithLocation(32, 26),
+                // (37,29): error CS0106: The modifier 'static' is not valid for this item
+                //     abstract static void I1.M01();
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M01").WithArguments("static").WithLocation(37, 29),
+                // (37,29): error CS0539: 'I8.M01()' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     abstract static void I1.M01();
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("I8.M01()").WithLocation(37, 29)
+                );
+
+            var m01 = compilation1.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I2").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I3").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I4").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I5").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I6").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I7").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I8").FindImplementationForInterfaceMember(m01));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_04(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+    abstract static void M02();
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test: I1
+{
+    static void I1.M01() {}
+    public static void M02() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,20): error CS8703: The modifier 'static' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     static void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("static", "9.0", "preview").WithLocation(4, 20)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (4,20): error CS8703: The modifier 'static' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     static void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("static", "9.0", "preview").WithLocation(4, 20),
+                // (10,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(10, 26),
+                // (11,26): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static void M02();
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M02").WithArguments("abstract", "9.0", "preview").WithLocation(11, 26)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_05(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    public static void M01() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (2,12): error CS8929: 'Test1.M01()' cannot implement interface member 'I1.M01()' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01()", "I1.M01()", "Test1").WithLocation(2, 12)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (2,12): error CS8929: 'Test1.M01()' cannot implement interface member 'I1.M01()' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01()", "I1.M01()", "Test1").WithLocation(2, 12),
+                // (9,26): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(9, 26)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_06(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    static void I1.M01() {}
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,20): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(4, 20)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (4,20): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(4, 20),
+                // (9,26): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static void M01();
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(9, 26)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_07(bool structure)
+        {
+            // Basic implicit implementation scenario, MethodImpl is emitted
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+" + typeKeyword + @"
+    C : I1
+{
+    public static void M01() {}
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.Ordinary, cM01.MethodKind);
+
+                Assert.Equal("void C.M01()", cM01.ToTestDisplayString());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_08(bool structure)
+        {
+            // Basic explicit implementation scenario
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+" + typeKeyword + @"
+    C : I1
+{
+    static void I1.M01() {}
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, cM01.MethodKind);
+
+                Assert.Equal("void C.I1.M01()", cM01.ToTestDisplayString());
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticMethod_09()
+        {
+            // Explicit implementation from base is treated as an implementation
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+public class C1
+{
+    public static void M01() {}
+}
+
+public class C2 : C1, I1
+{
+    static void I1.M01() {}
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                     parseOptions: parseOptions,
+                                                     targetFramework: TargetFramework.NetCoreApp,
+                                                     references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+                var m01 = c3.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                var cM01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+
+                Assert.Equal("void C2.I1.M01()", cM01.ToTestDisplayString());
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticMethod_10()
+        {
+            // Implicit implementation is considered only for types implementing interface in source.
+            // In metadata, only explicit implementations are considered
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig static abstract virtual 
+        void M01 () cil managed 
+    {
+    } // end of method I1::M01
+} // end of class I1
+
+.class public auto ansi beforefieldinit C1
+    extends System.Object
+    implements I1
+{
+    .method private hidebysig  
+        static void I1.M01 () cil managed 
+    {
+        .override method void I1::M01()
+        .maxstack 8
+
+        IL_0000: ret
+    } // end of method C1::I1.M01
+
+    .method public hidebysig static 
+        void M01 () cil managed 
+    {
+        IL_0000: ret
+    } // end of method C1::M01
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C1::.ctor
+} // end of class C1
+
+.class public auto ansi beforefieldinit C2
+    extends C1
+    implements I1
+{
+    .method public hidebysig static 
+        void M01 () cil managed 
+    {
+        IL_0000: ret
+    } // end of method C2::M01
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void C1::.ctor()
+        IL_0006: ret
+    } // end of method C2::.ctor
+} // end of class C2
+";
+            var source1 =
+@"
+public class C3 : C2
+{
+}
+
+public class C4 : C1, I1
+{
+}
+
+public class C5 : C2, I1
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+            var c1M01 = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+            Assert.Equal("void C1.I1.M01()", c1M01.ToTestDisplayString());
+            Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+
+            var c2 = compilation1.GlobalNamespace.GetTypeMember("C2");
+            Assert.Same(c1M01, c2.FindImplementationForInterfaceMember(m01));
+
+            var c3 = compilation1.GlobalNamespace.GetTypeMember("C3");
+            Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+
+            var c4 = compilation1.GlobalNamespace.GetTypeMember("C4");
+            Assert.Same(c1M01, c4.FindImplementationForInterfaceMember(m01));
+
+            var c5 = compilation1.GlobalNamespace.GetTypeMember("C5");
+
+            Assert.Equal("void C2.M01()", c5.FindImplementationForInterfaceMember(m01).ToTestDisplayString());
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticMethod_11()
+        {
+            // Ignore invalid metadata (non-abstract static virtual method). 
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig virtual 
+        static void M01 () cil managed 
+    {
+        IL_0000: ret
+    } // end of method I1::M01
+} // end of class I1
+";
+
+            var source1 =
+@"
+public class C1 : I1
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i1 = c1.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics();
+
+            var source2 =
+@"
+public class C1 : I1
+{
+   static void I1.M01() {}
+}
+";
+
+            var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation2.VerifyEmitDiagnostics(
+                // (4,19): error CS0539: 'C1.M01()' in explicit interface declaration is not found among members of the interface that can be implemented
+                //    static void I1.M01() {}
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C1.M01()").WithLocation(4, 19)
+                );
+
+            c1 = compilation2.GlobalNamespace.GetTypeMember("C1");
+            m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticMethod_12()
+        {
+            // Ignore invalid metadata (default interface implementation for a static method)
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig abstract virtual 
+        static void M01 () cil managed 
+    {
+    } // end of method I1::M01
+} // end of class I1
+.class interface public auto ansi abstract I2
+    implements I1
+{
+    // Methods
+    .method private hidebysig 
+        static void I1.M01 () cil managed 
+    {
+        .override method void I1::M01()
+        IL_0000: ret
+    } // end of method I2::I1.M01
+} // end of class I2
+";
+
+            var source1 =
+@"
+public class C1 : I2
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics(
+                // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01()'
+                // public class C1 : I2
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2").WithArguments("C1", "I1.M01()").WithLocation(2, 19)
+                );
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i2 = c1.Interfaces().Single();
+            var i1 = i2.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01));
+
+            var i2M01 = i2.GetMembers().OfType<MethodSymbol>().Single();
+            Assert.Same(m01, i2M01.ExplicitInterfaceImplementations.Single());
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticMethod_13()
+        {
+            // A forwarding method is added for an implicit implementation declared in base class. 
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+class C1
+{
+    public static void M01() {}
+}
+
+class C2 : C1, I1
+{
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+
+                var c2M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01.MethodKind);
+                    Assert.Equal("void C2.I1.M01()", c2M01.ToTestDisplayString());
+                    Assert.Same(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                    var c1M01 = module.GlobalNamespace.GetMember<MethodSymbol>("C1.M01");
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.False(c1M01.IsMetadataVirtual());
+                    Assert.False(c1M01.IsMetadataFinal);
+                    Assert.False(c1M01.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.Ordinary, c1M01.MethodKind);
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.Equal(MethodKind.Ordinary, c2M01.MethodKind);
+                    Assert.Equal("void C1.M01()", c2M01.ToTestDisplayString());
+                    Assert.Empty(c2M01.ExplicitInterfaceImplementations);
+                }
+            }
+
+            verifier.VerifyIL("C2.I1.M01()",
+@"
+{
+  // Code size        6 (0x6)
+  .maxstack  0
+  IL_0000:  call       ""void C1.M01()""
+  IL_0005:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticMethod_14()
+        {
+            // A forwarding method is added for an implicit implementation with modopt mismatch. 
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig abstract virtual 
+        static void modopt(I1) M01 () cil managed 
+    {
+    } // end of method I1::M01
+} // end of class I1
+";
+
+            var source1 =
+@"
+class C1 : I1
+{
+    public static void M01() {}
+}
+
+class C2 : I1
+{
+    static void I1.M01() {}
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c1 = module.GlobalNamespace.GetTypeMember("C1");
+                var m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                var c1M01 = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+                Assert.False(c1M01.IsMetadataVirtual());
+                Assert.False(c1M01.IsMetadataFinal);
+                Assert.False(c1M01.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01.MethodKind);
+                    Assert.Equal("void modopt(I1) C1.I1.M01()", c1M01.ToTestDisplayString());
+                    Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+
+                    c1M01 = module.GlobalNamespace.GetMember<MethodSymbol>("C1.M01");
+                    Assert.Equal("void C1.M01()", c1M01.ToTestDisplayString());
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.False(c1M01.IsMetadataVirtual());
+                    Assert.False(c1M01.IsMetadataFinal);
+                    Assert.False(c1M01.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.Ordinary, c1M01.MethodKind);
+
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.Equal(MethodKind.Ordinary, c1M01.MethodKind);
+                    Assert.Equal("void C1.M01()", c1M01.ToTestDisplayString());
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+
+                var c2M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01.MethodKind);
+
+                Assert.Equal("void modopt(I1) C2.I1.M01()", c2M01.ToTestDisplayString());
+                Assert.Same(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                Assert.Same(c2M01, c2.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Single());
+            }
+
+            verifier.VerifyIL("C1.I1.M01()",
+@"
+{
+  // Code size        6 (0x6)
+  .maxstack  0
+  IL_0000:  call       ""void C1.M01()""
+  IL_0005:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticMethod_15()
+        {
+            // A forwarding method isn't created if base class implements interface exactly the same way. 
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+    abstract static void M02();
+}
+
+public class C1
+{
+    public static void M01() {}
+}
+
+public class C2 : C1, I1
+{
+    static void I1.M02() {}
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.RegularPreview, TestOptions.Regular9 })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+
+                var m01 = c3.Interfaces().Single().GetMembers("M01").OfType<MethodSymbol>().Single();
+
+                var c1M01 = c3.BaseType().BaseType().GetMember<MethodSymbol>("M01");
+                Assert.Equal("void C1.M01()", c1M01.ToTestDisplayString());
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+                Assert.False(c1M01.IsMetadataVirtual());
+                Assert.False(c1M01.IsMetadataFinal);
+                Assert.False(c1M01.IsMetadataNewSlot());
+
+                Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+
+                if (c1M01.ContainingModule is PEModuleSymbol)
+                {
+                    var c2M01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+                    Assert.Equal("void C2.I1.M01()", c2M01.ToTestDisplayString());
+                    Assert.Same(m01, c2M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+                }
+
+                var m02 = c3.Interfaces().Single().GetMembers("M02").OfType<MethodSymbol>().Single();
+
+                var c2M02 = c3.BaseType().GetMember<MethodSymbol>("I1.M02");
+                Assert.Equal("void C2.I1.M02()", c2M02.ToTestDisplayString());
+                Assert.Same(c2M02, c3.FindImplementationForInterfaceMember(m02));
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticMethod_16()
+        {
+            // A new implicit implementation is properly considered.
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01();
+}
+
+public class C1 : I1
+{
+    public static void M01() {}
+}
+
+public class C2 : C1
+{
+    new public static void M01() {}
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    var verifier = CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+                    verifier.VerifyIL("C3.I1.M01()",
+@"
+{
+  // Code size        6 (0x6)
+  .maxstack  0
+  IL_0000:  call       ""void C2.M01()""
+  IL_0005:  ret
+}
+");
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                var m01 = c3.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                var c2M01 = c3.BaseType().GetMember<MethodSymbol>("M01");
+                Assert.Equal("void C2.M01()", c2M01.ToTestDisplayString());
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+
+                Assert.Empty(c2M01.ExplicitInterfaceImplementations);
+
+                if (module is PEModuleSymbol)
+                {
+                    var c3M01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+                    Assert.Equal("void C3.I1.M01()", c3M01.ToTestDisplayString());
+                    Assert.Same(m01, c3M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Same(c2M01, c3.FindImplementationForInterfaceMember(m01));
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_17(bool genericFirst)
+        {
+            // An "ambiguity" in implicit implementation declared in generic base class 
+
+            var generic =
+@"
+    public static void M01(T x) {}
+";
+            var nonGeneric =
+@"
+    public static void M01(int x) {}
+";
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01(int x);
+}
+
+public class C1<T> : I1
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count());
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C1<int>, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("void C1<T>.M01(System.Int32 x)", c1M01.OriginalDefinition.ToTestDisplayString());
+
+                var baseI1M01 = c2.BaseType().FindImplementationForInterfaceMember(m01);
+                Assert.Equal("void C1<T>.M01(System.Int32 x)", baseI1M01.OriginalDefinition.ToTestDisplayString());
+
+                Assert.Equal(c1M01, baseI1M01);
+
+                if (c1M01.OriginalDefinition.ContainingModule is PEModuleSymbol)
+                {
+                    Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_18(bool genericFirst)
+        {
+            // An "ambiguity" in implicit implementation declared in generic base class plus interface is generic too.
+
+            var generic =
+@"
+    public static void M01(T x) {}
+";
+            var nonGeneric =
+@"
+    public static void M01(int x) {}
+";
+            var source1 =
+@"
+public interface I1<T>
+{
+    abstract static void M01(T x);
+}
+
+public class C1<T> : I1<T>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count());
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C1<int>, I1<int>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("void C1<T>.M01(T x)", c1M01.OriginalDefinition.ToTestDisplayString());
+
+                var baseI1M01 = c2.BaseType().FindImplementationForInterfaceMember(m01);
+                Assert.Equal("void C1<T>.M01(T x)", baseI1M01.OriginalDefinition.ToTestDisplayString());
+
+                Assert.Equal(c1M01, baseI1M01);
+
+                if (c1M01.OriginalDefinition.ContainingModule is PEModuleSymbol)
+                {
+                    Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_19(bool genericFirst)
+        {
+            // Same as ImplementAbstractStaticMethod_17 only implementation is explicit in source.
+
+            var generic =
+@"
+    public static void M01(T x) {}
+";
+            var nonGeneric =
+@"
+    static void I1.M01(int x) {}
+";
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01(int x);
+}
+
+public class C1<T> : I1
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count());
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C1<int>, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("void C1<T>.I1.M01(System.Int32 x)", c1M01.OriginalDefinition.ToTestDisplayString());
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c1M01, c2.BaseType().FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_20(bool genericFirst)
+        {
+            // Same as ImplementAbstractStaticMethod_18 only implementation is explicit in source.
+
+            var generic =
+@"
+    static void I1<T>.M01(T x) {}
+";
+            var nonGeneric =
+@"
+    public static void M01(int x) {}
+";
+            var source1 =
+@"
+public interface I1<T>
+{
+    abstract static void M01(T x);
+}
+
+public class C1<T> : I1<T>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count());
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C1<int>, I1<int>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("void C1<T>.I1<T>.M01(T x)", c1M01.OriginalDefinition.ToTestDisplayString());
+                Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c1M01, c2.BaseType().FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_21(bool genericFirst)
+        {
+            // Same as ImplementAbstractStaticMethod_17 only implicit implementation is in an intermediate base.
+
+            var generic =
+@"
+    public static void M01(T x) {}
+";
+            var nonGeneric =
+@"
+    public static void M01(int x) {}
+";
+            var source1 =
+@"
+public interface I1
+{
+    abstract static void M01(int x);
+}
+
+public class C1<T>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+
+public class C11<T> : C1<T>, I1
+{
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count());
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C11<int>, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                var expectedDisplay = m01.ContainingModule is PEModuleSymbol ? "void C11<T>.I1.M01(System.Int32 x)" : "void C1<T>.M01(System.Int32 x)";
+                Assert.Equal(expectedDisplay, c1M01.OriginalDefinition.ToTestDisplayString());
+
+                var baseI1M01 = c2.BaseType().FindImplementationForInterfaceMember(m01);
+                Assert.Equal(expectedDisplay, baseI1M01.OriginalDefinition.ToTestDisplayString());
+
+                Assert.Equal(c1M01, baseI1M01);
+
+                if (c1M01.OriginalDefinition.ContainingModule is PEModuleSymbol)
+                {
+                    Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticMethod_22(bool genericFirst)
+        {
+            // Same as ImplementAbstractStaticMethod_18 only implicit implementation is in an intermediate base.
+
+            var generic =
+@"
+    public static void M01(T x) {}
+";
+            var nonGeneric =
+@"
+    public static void M01(int x) {}
+";
+            var source1 =
+@"
+public interface I1<T>
+{
+    abstract static void M01(T x);
+}
+
+public class C1<T>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+
+public class C11<T> : C1<T>, I1<T>
+{
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count());
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C11<int>, I1<int>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                var expectedDisplay = m01.ContainingModule is PEModuleSymbol ? "void C11<T>.I1<T>.M01(T x)" : "void C1<T>.M01(T x)";
+                Assert.Equal(expectedDisplay, c1M01.OriginalDefinition.ToTestDisplayString());
+
+                var baseI1M01 = c2.BaseType().FindImplementationForInterfaceMember(m01);
+                Assert.Equal(expectedDisplay, baseI1M01.OriginalDefinition.ToTestDisplayString());
+
+                Assert.Equal(c1M01, baseI1M01);
+
+                if (c1M01.OriginalDefinition.ContainingModule is PEModuleSymbol)
+                {
+                    Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        private static string UnaryOperatorName(string op) => OperatorFacts.UnaryOperatorNameFromSyntaxKindIfAny(SyntaxFactory.ParseToken(op).Kind());
+        private static string BinaryOperatorName(string op) => op switch { ">>" => WellKnownMemberNames.RightShiftOperatorName, _ => OperatorFacts.BinaryOperatorNameFromSyntaxKindIfAny(SyntaxFactory.ParseToken(op).Kind()) };
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_01([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            string opName = UnaryOperatorName(op);
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static T operator " + op + @"(T x);
+}
+
+" + typeKeyword + @"
+    C1 : I1<C1>
+{}
+
+" + typeKeyword + @"
+    C2 : I1<C2>
+{
+    public C2 operator " + op + @"(C2 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C3 : I1<C3>
+{
+    static C3 operator " + op + @"(C3 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C4 : I1<C4>
+{
+    C4 I1<C4>.operator " + op + @"(C4 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C5 : I1<C5>
+{
+    public static int operator " + op + @" (C5 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C6 : I1<C6>
+{
+    static int I1<C6>.operator " + op + @" (C6 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C7 : I1<C7>
+{
+    public static C7 " + opName + @"(C7 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C8 : I1<C8>
+{
+    static C8 I1<C8>." + opName + @"(C8 x) => throw null;
+}
+
+public interface I2<T> where T : I2<T>
+{
+    abstract static T " + opName + @"(T x);
+}
+
+" + typeKeyword + @"
+    C9 : I2<C9>
+{
+    public static C9 operator " + op + @"(C9 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C10 : I2<C10>
+{
+    static C10 I2<C10>.operator " + op + @"(C10 x) => throw null;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_BadIncDecRetType or (int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.ERR_OpTFRetType)).Verify(
+                // (8,10): error CS0535: 'C1' does not implement interface member 'I1<C1>.operator +(C1)'
+                //     C1 : I1<C1>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C1>").WithArguments("C1", "I1<C1>.operator " + op + "(C1)").WithLocation(8, 10),
+                // (12,10): error CS8928: 'C2' does not implement static interface member 'I1<C2>.operator +(C2)'. 'C2.operator +(C2)' cannot implement the interface member because it is not static.
+                //     C2 : I1<C2>
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotStatic, "I1<C2>").WithArguments("C2", "I1<C2>.operator " + op + "(C2)", "C2.operator " + op + "(C2)").WithLocation(12, 10),
+                // (14,24): error CS0558: User-defined operator 'C2.operator +(C2)' must be declared static and public
+                //     public C2 operator +(C2 x) => throw null;
+                Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, op).WithArguments("C2.operator " + op + "(C2)").WithLocation(14, 24),
+                // (18,10): error CS0737: 'C3' does not implement interface member 'I1<C3>.operator +(C3)'. 'C3.operator +(C3)' cannot implement an interface member because it is not public.
+                //     C3 : I1<C3>
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "I1<C3>").WithArguments("C3", "I1<C3>.operator " + op + "(C3)", "C3.operator " + op + "(C3)").WithLocation(18, 10),
+                // (20,24): error CS0558: User-defined operator 'C3.operator +(C3)' must be declared static and public
+                //     static C3 operator +(C3 x) => throw null;
+                Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, op).WithArguments("C3.operator " + op + "(C3)").WithLocation(20, 24),
+                // (24,10): error CS0535: 'C4' does not implement interface member 'I1<C4>.operator +(C4)'
+                //     C4 : I1<C4>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C4>").WithArguments("C4", "I1<C4>.operator " + op + "(C4)").WithLocation(24, 10),
+                // (26,24): error CS8930: Explicit implementation of a user-defined operator 'C4.operator +(C4)' must be declared static
+                //     C4 I1<C4>.operator +(C4 x) => throw null;
+                Diagnostic(ErrorCode.ERR_ExplicitImplementationOfOperatorsMustBeStatic, op).WithArguments("C4.operator " + op + "(C4)").WithLocation(26, 24),
+                // (26,24): error CS0539: 'C4.operator +(C4)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     C4 I1<C4>.operator +(C4 x) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("C4.operator " + op + "(C4)").WithLocation(26, 24),
+                // (30,10): error CS0738: 'C5' does not implement interface member 'I1<C5>.operator +(C5)'. 'C5.operator +(C5)' cannot implement 'I1<C5>.operator +(C5)' because it does not have the matching return type of 'C5'.
+                //     C5 : I1<C5>
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1<C5>").WithArguments("C5", "I1<C5>.operator " + op + "(C5)", "C5.operator " + op + "(C5)", "C5").WithLocation(30, 10),
+                // (36,10): error CS0535: 'C6' does not implement interface member 'I1<C6>.operator +(C6)'
+                //     C6 : I1<C6>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C6>").WithArguments("C6", "I1<C6>.operator " + op + "(C6)").WithLocation(36, 10),
+                // (38,32): error CS0539: 'C6.operator +(C6)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static int I1<C6>.operator + (C6 x) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("C6.operator " + op + "(C6)").WithLocation(38, 32),
+                // (42,10): error CS0535: 'C7' does not implement interface member 'I1<C7>.operator +(C7)'
+                //     C7 : I1<C7>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C7>").WithArguments("C7", "I1<C7>.operator " + op + "(C7)").WithLocation(42, 10),
+                // (48,10): error CS0535: 'C8' does not implement interface member 'I1<C8>.operator +(C8)'
+                //     C8 : I1<C8>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C8>").WithArguments("C8", "I1<C8>.operator " + op + "(C8)").WithLocation(48, 10),
+                // (50,22): error CS0539: 'C8.op_UnaryPlus(C8)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static C8 I1<C8>.op_UnaryPlus(C8 x) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, opName).WithArguments("C8." + opName + "(C8)").WithLocation(50, 22),
+                // (59,10): error CS0535: 'C9' does not implement interface member 'I2<C9>.op_UnaryPlus(C9)'
+                //     C9 : I2<C9>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2<C9>").WithArguments("C9", "I2<C9>." + opName + "(C9)").WithLocation(59, 10),
+                // (65,11): error CS0535: 'C10' does not implement interface member 'I2<C10>.op_UnaryPlus(C10)'
+                //     C10 : I2<C10>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2<C10>").WithArguments("C10", "I2<C10>." + opName + "(C10)").WithLocation(65, 11),
+                // (67,33): error CS0539: 'C10.operator +(C10)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static C10 I2<C10>.operator +(C10 x) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("C10.operator " + op + "(C10)").WithLocation(67, 33)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_01([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            string opName = BinaryOperatorName(op);
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static T operator " + op + @"(T x, int y);
+}
+
+" + typeKeyword + @"
+    C1 : I1<C1>
+{}
+
+" + typeKeyword + @"
+    C2 : I1<C2>
+{
+    public C2 operator " + op + @"(C2 x, int y) => throw null;
+}
+
+" + typeKeyword + @"
+    C3 : I1<C3>
+{
+    static C3 operator " + op + @"(C3 x, int y) => throw null;
+}
+
+" + typeKeyword + @"
+    C4 : I1<C4>
+{
+    C4 I1<C4>.operator " + op + @"(C4 x, int y) => throw null;
+}
+
+" + typeKeyword + @"
+    C5 : I1<C5>
+{
+    public static int operator " + op + @" (C5 x, int y) => throw null;
+}
+
+" + typeKeyword + @"
+    C6 : I1<C6>
+{
+    static int I1<C6>.operator " + op + @" (C6 x, int y) => throw null;
+}
+
+" + typeKeyword + @"
+    C7 : I1<C7>
+{
+    public static C7 " + opName + @"(C7 x, int y) => throw null;
+}
+
+" + typeKeyword + @"
+    C8 : I1<C8>
+{
+    static C8 I1<C8>." + opName + @"(C8 x, int y) => throw null;
+}
+
+public interface I2<T> where T : I2<T>
+{
+    abstract static T " + opName + @"(T x, int y);
+}
+
+" + typeKeyword + @"
+    C9 : I2<C9>
+{
+    public static C9 operator " + op + @"(C9 x, int y) => throw null;
+}
+
+" + typeKeyword + @"
+    C10 : I2<C10>
+{
+    static C10 I2<C10>.operator " + op + @"(C10 x, int y) => throw null;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.WRN_EqualityOpWithoutEquals or (int)ErrorCode.WRN_EqualityOpWithoutGetHashCode)).Verify(
+                // (8,10): error CS0535: 'C1' does not implement interface member 'I1<C1>.operator >>(C1, int)'
+                //     C1 : I1<C1>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C1>").WithArguments("C1", "I1<C1>.operator " + op + "(C1, int)").WithLocation(8, 10),
+                // (12,10): error CS8928: 'C2' does not implement static interface member 'I1<C2>.operator >>(C2, int)'. 'C2.operator >>(C2, int)' cannot implement the interface member because it is not static.
+                //     C2 : I1<C2>
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotStatic, "I1<C2>").WithArguments("C2", "I1<C2>.operator " + op + "(C2, int)", "C2.operator " + op + "(C2, int)").WithLocation(12, 10),
+                // (14,24): error CS0558: User-defined operator 'C2.operator >>(C2, int)' must be declared static and public
+                //     public C2 operator >>(C2 x, int y) => throw null;
+                Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, op).WithArguments("C2.operator " + op + "(C2, int)").WithLocation(14, 24),
+                // (18,10): error CS0737: 'C3' does not implement interface member 'I1<C3>.operator >>(C3, int)'. 'C3.operator >>(C3, int)' cannot implement an interface member because it is not public.
+                //     C3 : I1<C3>
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "I1<C3>").WithArguments("C3", "I1<C3>.operator " + op + "(C3, int)", "C3.operator " + op + "(C3, int)").WithLocation(18, 10),
+                // (20,24): error CS0558: User-defined operator 'C3.operator >>(C3, int)' must be declared static and public
+                //     static C3 operator >>(C3 x, int y) => throw null;
+                Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, op).WithArguments("C3.operator " + op + "(C3, int)").WithLocation(20, 24),
+                // (24,10): error CS0535: 'C4' does not implement interface member 'I1<C4>.operator >>(C4, int)'
+                //     C4 : I1<C4>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C4>").WithArguments("C4", "I1<C4>.operator " + op + "(C4, int)").WithLocation(24, 10),
+                // (26,24): error CS8930: Explicit implementation of a user-defined operator 'C4.operator >>(C4, int)' must be declared static
+                //     C4 I1<C4>.operator >>(C4 x, int y) => throw null;
+                Diagnostic(ErrorCode.ERR_ExplicitImplementationOfOperatorsMustBeStatic, op).WithArguments("C4.operator " + op + "(C4, int)").WithLocation(26, 24),
+                // (26,24): error CS0539: 'C4.operator >>(C4, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     C4 I1<C4>.operator >>(C4 x, int y) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("C4.operator " + op + "(C4, int)").WithLocation(26, 24),
+                // (30,10): error CS0738: 'C5' does not implement interface member 'I1<C5>.operator >>(C5, int)'. 'C5.operator >>(C5, int)' cannot implement 'I1<C5>.operator >>(C5, int)' because it does not have the matching return type of 'C5'.
+                //     C5 : I1<C5>
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1<C5>").WithArguments("C5", "I1<C5>.operator " + op + "(C5, int)", "C5.operator " + op + "(C5, int)", "C5").WithLocation(30, 10),
+                // (36,10): error CS0535: 'C6' does not implement interface member 'I1<C6>.operator >>(C6, int)'
+                //     C6 : I1<C6>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C6>").WithArguments("C6", "I1<C6>.operator " + op + "(C6, int)").WithLocation(36, 10),
+                // (38,32): error CS0539: 'C6.operator >>(C6, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static int I1<C6>.operator >> (C6 x, int y) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("C6.operator " + op + "(C6, int)").WithLocation(38, 32),
+                // (42,10): error CS0535: 'C7' does not implement interface member 'I1<C7>.operator >>(C7, int)'
+                //     C7 : I1<C7>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C7>").WithArguments("C7", "I1<C7>.operator " + op + "(C7, int)").WithLocation(42, 10),
+                // (48,10): error CS0535: 'C8' does not implement interface member 'I1<C8>.operator >>(C8, int)'
+                //     C8 : I1<C8>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C8>").WithArguments("C8", "I1<C8>.operator " + op + "(C8, int)").WithLocation(48, 10),
+                // (50,22): error CS0539: 'C8.op_RightShift(C8, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static C8 I1<C8>.op_RightShift(C8 x, int y) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, opName).WithArguments("C8." + opName + "(C8, int)").WithLocation(50, 22),
+                // (59,10): error CS0535: 'C9' does not implement interface member 'I2<C9>.op_RightShift(C9, int)'
+                //     C9 : I2<C9>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2<C9>").WithArguments("C9", "I2<C9>." + opName + "(C9, int)").WithLocation(59, 10),
+                // (65,11): error CS0535: 'C10' does not implement interface member 'I2<C10>.op_RightShift(C10, int)'
+                //     C10 : I2<C10>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2<C10>").WithArguments("C10", "I2<C10>." + opName + "(C10, int)").WithLocation(65, 11),
+                // (67,33): error CS0539: 'C10.operator >>(C10, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static C10 I2<C10>.operator >>(C10 x, int y) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("C10.operator " + op + "(C10, int)").WithLocation(67, 33)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_03([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x);
+}
+
+interface I2 : I1
+{}
+
+interface I3 : I1
+{
+    I1 operator " + op + @"(I1 x) => default;
+}
+
+interface I4 : I1
+{
+    static I1 operator " + op + @"(I1 x) => default;
+}
+
+interface I5 : I1
+{
+    I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+interface I6 : I1
+{
+    static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+interface I7 : I1
+{
+    abstract static I1 operator " + op + @"(I1 x);
+}
+
+public interface I11<T> where T : I11<T>
+{
+    abstract static T operator " + op + @"(T x);
+}
+
+interface I8<T> : I11<T> where T : I8<T>
+{
+    T operator " + op + @"(T x) => default;
+}
+
+interface I9<T> : I11<T> where T : I9<T>
+{
+    static T operator " + op + @"(T x) => default;
+}
+
+interface I10<T> : I11<T> where T : I10<T>
+{
+    abstract static T operator " + op + @"(T x);
+}
+
+interface I12<T> : I11<T> where T : I12<T>
+{
+    static T I11<T>.operator " + op + @"(T x) => default;
+}
+
+interface I13<T> : I11<T> where T : I13<T>
+{
+    abstract static T I11<T>.operator " + op + @"(T x);
+}
+
+interface I14 : I1
+{
+    abstract static I1 I1.operator " + op + @"(I1 x);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            ErrorCode badSignatureError = op.Length != 2 ? ErrorCode.ERR_BadUnaryOperatorSignature : ErrorCode.ERR_BadIncDecSignature;
+            ErrorCode badAbstractSignatureError = op.Length != 2 ? ErrorCode.ERR_BadAbstractUnaryOperatorSignature : ErrorCode.ERR_BadAbstractIncDecSignature;
+
+            compilation1.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.ERR_OpTFRetType)).Verify(
+                // (12,17): error CS0558: User-defined operator 'I3.operator +(I1)' must be declared static and public
+                //     I1 operator +(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, op).WithArguments("I3.operator " + op + "(I1)").WithLocation(12, 17),
+                // (12,17): error CS0562: The parameter of a unary operator must be the containing type
+                //     I1 operator +(I1 x) => default;
+                Diagnostic(badSignatureError, op).WithLocation(12, 17),
+                // (17,24): error CS0562: The parameter of a unary operator must be the containing type
+                //     static I1 operator +(I1 x) => default;
+                Diagnostic(badSignatureError, op).WithLocation(17, 24),
+                // (22,20): error CS8930: Explicit implementation of a user-defined operator 'I5.operator +(I1)' must be declared static
+                //     I1 I1.operator +(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_ExplicitImplementationOfOperatorsMustBeStatic, op).WithArguments("I5.operator " + op + "(I1)").WithLocation(22, 20),
+                // (22,20): error CS0539: 'I5.operator +(I1)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     I1 I1.operator +(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I5.operator " + op + "(I1)").WithLocation(22, 20),
+                // (27,27): error CS0539: 'I6.operator +(I1)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static I1 I1.operator +(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I6.operator " + op + "(I1)").WithLocation(27, 27),
+                // (32,33): error CS8921: The parameter of a unary operator must be the containing type, or its type parameter constrained to it.
+                //     abstract static I1 operator +(I1 x);
+                Diagnostic(badAbstractSignatureError, op).WithLocation(32, 33),
+                // (42,16): error CS0558: User-defined operator 'I8<T>.operator +(T)' must be declared static and public
+                //     T operator +(T x) => default;
+                Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, op).WithArguments("I8<T>.operator " + op + "(T)").WithLocation(42, 16),
+                // (42,16): error CS0562: The parameter of a unary operator must be the containing type
+                //     T operator +(T x) => default;
+                Diagnostic(badSignatureError, op).WithLocation(42, 16),
+                // (47,23): error CS0562: The parameter of a unary operator must be the containing type
+                //     static T operator +(T x) => default;
+                Diagnostic(badSignatureError, op).WithLocation(47, 23),
+                // (57,30): error CS0539: 'I12<T>.operator +(T)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static T I11<T>.operator +(T x) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I12<T>.operator " + op + "(T)").WithLocation(57, 30),
+                // (62,39): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static T I11<T>.operator +(T x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("abstract").WithLocation(62, 39),
+                // (62,39): error CS0501: 'I13<T>.operator +(T)' must declare a body because it is not marked abstract, extern, or partial
+                //     abstract static T I11<T>.operator +(T x);
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, op).WithArguments("I13<T>.operator " + op + "(T)").WithLocation(62, 39),
+                // (62,39): error CS0539: 'I13<T>.operator +(T)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     abstract static T I11<T>.operator +(T x);
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I13<T>.operator " + op + "(T)").WithLocation(62, 39),
+                // (67,36): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static I1 I1.operator +(I1 x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("abstract").WithLocation(67, 36),
+                // (67,36): error CS0501: 'I14.operator +(I1)' must declare a body because it is not marked abstract, extern, or partial
+                //     abstract static I1 I1.operator +(I1 x);
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, op).WithArguments("I14.operator " + op + "(I1)").WithLocation(67, 36),
+                // (67,36): error CS0539: 'I14.operator +(I1)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     abstract static I1 I1.operator +(I1 x);
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I14.operator " + op + "(I1)").WithLocation(67, 36)
+                );
+
+            var m01 = compilation1.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I2").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I3").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I4").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I5").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I6").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I7").FindImplementationForInterfaceMember(m01));
+
+            var i8 = compilation1.GlobalNamespace.GetTypeMember("I8");
+            Assert.Null(i8.FindImplementationForInterfaceMember(i8.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i9 = compilation1.GlobalNamespace.GetTypeMember("I9");
+            Assert.Null(i9.FindImplementationForInterfaceMember(i9.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i10 = compilation1.GlobalNamespace.GetTypeMember("I10");
+            Assert.Null(i10.FindImplementationForInterfaceMember(i10.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i12 = compilation1.GlobalNamespace.GetTypeMember("I12");
+            Assert.Null(i12.FindImplementationForInterfaceMember(i12.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i13 = compilation1.GlobalNamespace.GetTypeMember("I13");
+            Assert.Null(i13.FindImplementationForInterfaceMember(i13.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I14").FindImplementationForInterfaceMember(m01));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_03([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x, int y);
+}
+
+interface I2 : I1
+{}
+
+interface I3 : I1
+{
+    I1 operator " + op + @"(I1 x, int y) => default;
+}
+
+interface I4 : I1
+{
+    static I1 operator " + op + @"(I1 x, int y) => default;
+}
+
+interface I5 : I1
+{
+    I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+interface I6 : I1
+{
+    static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+interface I7 : I1
+{
+    abstract static I1 operator " + op + @"(I1 x, int y);
+}
+
+public interface I11<T> where T : I11<T>
+{
+    abstract static T operator " + op + @"(T x, int y);
+}
+
+interface I8<T> : I11<T> where T : I8<T>
+{
+    T operator " + op + @"(T x, int y) => default;
+}
+
+interface I9<T> : I11<T> where T : I9<T>
+{
+    static T operator " + op + @"(T x, int y) => default;
+}
+
+interface I10<T> : I11<T> where T : I10<T>
+{
+    abstract static T operator " + op + @"(T x, int y);
+}
+
+interface I12<T> : I11<T> where T : I12<T>
+{
+    static T I11<T>.operator " + op + @"(T x, int y) => default;
+}
+
+interface I13<T> : I11<T> where T : I13<T>
+{
+    abstract static T I11<T>.operator " + op + @"(T x, int y);
+}
+
+interface I14 : I1
+{
+    abstract static I1 I1.operator " + op + @"(I1 x, int y);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            bool isShift = op == "<<" || op == ">>";
+            ErrorCode badSignatureError = isShift ? ErrorCode.ERR_BadShiftOperatorSignature : ErrorCode.ERR_BadBinaryOperatorSignature;
+            ErrorCode badAbstractSignatureError = isShift ? ErrorCode.ERR_BadAbstractShiftOperatorSignature : ErrorCode.ERR_BadAbstractBinaryOperatorSignature;
+
+            var expected = new[] {
+                // (12,17): error CS0563: One of the parameters of a binary operator must be the containing type
+                //     I1 operator |(I1 x, int y) => default;
+                Diagnostic(badSignatureError, op).WithLocation(12, 17),
+                // (17,24): error CS0563: One of the parameters of a binary operator must be the containing type
+                //     static I1 operator |(I1 x, int y) => default;
+                Diagnostic(badSignatureError, op).WithLocation(17, 24),
+                // (22,20): error CS8930: Explicit implementation of a user-defined operator 'I5.operator |(I1, int)' must be declared static
+                //     I1 I1.operator |(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_ExplicitImplementationOfOperatorsMustBeStatic, op).WithArguments("I5.operator " + op + "(I1, int)").WithLocation(22, 20),
+                // (22,20): error CS0539: 'I5.operator |(I1, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     I1 I1.operator |(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I5.operator " + op + "(I1, int)").WithLocation(22, 20),
+                // (27,27): error CS0539: 'I6.operator |(I1, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static I1 I1.operator |(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I6.operator " + op + "(I1, int)").WithLocation(27, 27),
+                // (32,33): error CS8924: One of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
+                //     abstract static I1 operator |(I1 x, int y);
+                Diagnostic(badAbstractSignatureError, op).WithLocation(32, 33),
+                // (42,16): error CS0563: One of the parameters of a binary operator must be the containing type
+                //     T operator |(T x, int y) => default;
+                Diagnostic(badSignatureError, op).WithLocation(42, 16),
+                // (47,23): error CS0563: One of the parameters of a binary operator must be the containing type
+                //     static T operator |(T x, int y) => default;
+                Diagnostic(badSignatureError, op).WithLocation(47, 23),
+                // (57,30): error CS0539: 'I12<T>.operator |(T, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static T I11<T>.operator |(T x, int y) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I12<T>.operator " + op + "(T, int)").WithLocation(57, 30),
+                // (62,39): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static T I11<T>.operator |(T x, int y);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("abstract").WithLocation(62, 39),
+                // (62,39): error CS0501: 'I13<T>.operator |(T, int)' must declare a body because it is not marked abstract, extern, or partial
+                //     abstract static T I11<T>.operator |(T x, int y);
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, op).WithArguments("I13<T>.operator " + op + "(T, int)").WithLocation(62, 39),
+                // (62,39): error CS0539: 'I13<T>.operator |(T, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     abstract static T I11<T>.operator |(T x, int y);
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I13<T>.operator " + op + "(T, int)").WithLocation(62, 39),
+                // (67,36): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static I1 I1.operator |(I1 x, int y);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("abstract").WithLocation(67, 36),
+                // (67,36): error CS0501: 'I14.operator |(I1, int)' must declare a body because it is not marked abstract, extern, or partial
+                //     abstract static I1 I1.operator |(I1 x, int y);
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, op).WithArguments("I14.operator " + op + "(I1, int)").WithLocation(67, 36),
+                // (67,36): error CS0539: 'I14.operator |(I1, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     abstract static I1 I1.operator |(I1 x, int y);
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("I14.operator " + op + "(I1, int)").WithLocation(67, 36)
+                };
+
+            if (op is "==" or "!=")
+            {
+                expected = expected.Concat(
+                    new[] {
+                        // (12,17): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                        //     I1 operator ==(I1 x, int y) => default;
+                        Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, op).WithLocation(12, 17),
+                        // (17,24): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                        //     static I1 operator ==(I1 x, int y) => default;
+                        Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, op).WithLocation(17, 24),
+                        // (42,16): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                        //     T operator ==(T x, int y) => default;
+                        Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, op).WithLocation(42, 16),
+                        // (47,23): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                        //     static T operator ==(T x, int y) => default;
+                        Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, op).WithLocation(47, 23),
+                        }
+                    ).ToArray();
+            }
+            else
+            {
+                expected = expected.Concat(
+                    new[] {
+                        // (12,17): error CS0558: User-defined operator 'I3.operator |(I1, int)' must be declared static and public
+                        //     I1 operator |(I1 x, int y) => default;
+                        Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, op).WithArguments("I3.operator " + op + "(I1, int)").WithLocation(12, 17),
+                        // (42,16): error CS0558: User-defined operator 'I8<T>.operator |(T, int)' must be declared static and public
+                        //     T operator |(T x, int y) => default;
+                        Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, op).WithArguments("I8<T>.operator " + op + "(T, int)").WithLocation(42, 16)
+                        }
+                    ).ToArray();
+            }
+
+            compilation1.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_OperatorNeedsMatch).Verify(expected);
+
+            var m01 = compilation1.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I2").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I3").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I4").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I5").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I6").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I7").FindImplementationForInterfaceMember(m01));
+
+            var i8 = compilation1.GlobalNamespace.GetTypeMember("I8");
+            Assert.Null(i8.FindImplementationForInterfaceMember(i8.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i9 = compilation1.GlobalNamespace.GetTypeMember("I9");
+            Assert.Null(i9.FindImplementationForInterfaceMember(i9.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i10 = compilation1.GlobalNamespace.GetTypeMember("I10");
+            Assert.Null(i10.FindImplementationForInterfaceMember(i10.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i12 = compilation1.GlobalNamespace.GetTypeMember("I12");
+            Assert.Null(i12.FindImplementationForInterfaceMember(i12.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i13 = compilation1.GlobalNamespace.GetTypeMember("I13");
+            Assert.Null(i13.FindImplementationForInterfaceMember(i13.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I14").FindImplementationForInterfaceMember(m01));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_04([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x);
+}
+
+public interface I2<T> where T : I2<T>
+{
+    abstract static T operator " + op + @"(T x);
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    static I1 I1.operator " + op + @"(I1 x) => default;
+}
+" + typeKeyword + @"
+    Test2: I2<Test2>
+{
+    public static Test2 operator " + op + @"(Test2 x) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.ERR_OpTFRetType)).Verify(
+                // (4,15): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //     static I1 I1.operator +(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I1.").WithArguments("static abstract members in interfaces").WithLocation(4, 15)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.ERR_OpTFRetType)).Verify(
+                // (4,15): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //     static I1 I1.operator +(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I1.").WithArguments("static abstract members in interfaces").WithLocation(4, 15),
+                // (14,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static I1 operator +(I1 x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, op).WithArguments("abstract", "9.0", "preview").WithLocation(14, 33),
+                // (19,32): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static T operator +(T x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, op).WithArguments("abstract", "9.0", "preview").WithLocation(19, 32)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_04([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x, int y);
+}
+
+public interface I2<T> where T : I2<T>
+{
+    abstract static T operator " + op + @"(T x, int y);
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+" + typeKeyword + @"
+    Test2: I2<Test2>
+{
+    public static Test2 operator " + op + @"(Test2 x, int y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.WRN_EqualityOpWithoutEquals or (int)ErrorCode.WRN_EqualityOpWithoutGetHashCode)).Verify(
+                // (4,15): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //     static I1 I1.operator +(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I1.").WithArguments("static abstract members in interfaces").WithLocation(4, 15)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.WRN_EqualityOpWithoutEquals or (int)ErrorCode.WRN_EqualityOpWithoutGetHashCode)).Verify(
+                // (4,15): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //     static I1 I1.operator +(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I1.").WithArguments("static abstract members in interfaces").WithLocation(4, 15),
+                // (14,33): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static I1 operator +(I1 x, int y);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, op).WithArguments("abstract", "9.0", "preview").WithLocation(14, 33),
+                // (19,32): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static T operator +(T x, int y);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, op).WithArguments("abstract", "9.0", "preview").WithLocation(19, 32)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_05([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T> 
+{
+    abstract static T operator " + op + @"(T x);
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1<Test1>
+{
+    public static Test1 operator " + op + @"(Test1 x) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.ERR_OpTFRetType)).Verify(
+                // (2,12): error CS8929: 'Test1.operator +(Test1)' cannot implement interface member 'I1<Test1>.operator +(Test1)' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1<Test1>
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1<Test1>").WithArguments("Test1.operator " + op + "(Test1)", "I1<Test1>.operator " + op + "(Test1)", "Test1").WithLocation(2, 12)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.ERR_OpTFRetType)).Verify(
+                // (2,12): error CS8929: 'Test1.operator +(Test1)' cannot implement interface member 'I1<Test1>.operator +(Test1)' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1<Test1>
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1<Test1>").WithArguments("Test1.operator " + op + "(Test1)", "I1<Test1>.operator " + op + "(Test1)", "Test1").WithLocation(2, 12),
+                // (9,32): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static T operator +(T x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(9, 32)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_05([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T> 
+{
+    abstract static T operator " + op + @"(T x, int y);
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1<Test1>
+{
+    public static Test1 operator " + op + @"(Test1 x, int y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.WRN_EqualityOpWithoutEquals or (int)ErrorCode.WRN_EqualityOpWithoutGetHashCode)).Verify(
+                // (2,12): error CS8929: 'Test1.operator >>(Test1, int)' cannot implement interface member 'I1<Test1>.operator >>(Test1, int)' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1<Test1>
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1<Test1>").WithArguments("Test1.operator " + op + "(Test1, int)", "I1<Test1>.operator " + op + "(Test1, int)", "Test1").WithLocation(2, 12)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.WRN_EqualityOpWithoutEquals or (int)ErrorCode.WRN_EqualityOpWithoutGetHashCode)).Verify(
+                // (2,12): error CS8929: 'Test1.operator >>(Test1, int)' cannot implement interface member 'I1<Test1>.operator >>(Test1, int)' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1<Test1>
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1<Test1>").WithArguments("Test1.operator " + op + "(Test1, int)", "I1<Test1>.operator " + op + "(Test1, int)", "Test1").WithLocation(2, 12),
+                // (9,32): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static T operator >>(T x, int y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(9, 32)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_06([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x);
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    static I1 I1.operator " + op + @"(I1 x) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,27): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static I1 I1.operator +(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(4, 27)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OperatorNeedsMatch or (int)ErrorCode.ERR_OpTFRetType)).Verify(
+                // (4,27): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static I1 I1.operator +(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(4, 27),
+                // (9,33): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator +(I1 x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(9, 33)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_06([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x, int y);
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,27): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static I1 I1.operator +(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(4, 27)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_OperatorNeedsMatch).Verify(
+                // (4,27): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static I1 I1.operator +(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(4, 27),
+                // (9,33): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static I1 operator +(I1 x, int y);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, op).WithLocation(9, 33)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_07([CombinatorialValues("+", "-", "!", "~", "++", "--")] string op, bool structure)
+        {
+            // Basic implicit implementation scenario, MethodImpl is emitted
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static T operator " + op + @"(T x);
+}
+
+" + typeKeyword + @"
+    C : I1<C>
+{
+    public static C operator " + op + @"(C x) => default;
+}
+";
+
+            var opName = UnaryOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c = module.GlobalNamespace.GetTypeMember("C");
+                var i1 = c.Interfaces().Single();
+                var m01 = i1.GetMembers().OfType<MethodSymbol>().Single();
+
+                Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.UserDefinedOperator, cM01.MethodKind);
+                Assert.False(cM01.HasRuntimeSpecialName);
+                Assert.True(cM01.HasSpecialName);
+
+                Assert.Equal("C C." + opName + "(C x)", cM01.ToTestDisplayString());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(m01, cM01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryTrueFalseOperator_07([CombinatorialValues("true", "false")] string op, bool structure)
+        {
+            // Basic implicit implementation scenario, MethodImpl is emitted
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public partial interface I1<T> where T : I1<T>
+{
+    abstract static bool operator " + op + @"(T x);
+}
+
+partial " + typeKeyword + @"
+    C : I1<C>
+{
+    public static bool operator " + op + @"(C x) => default;
+}
+";
+            string matchingOp = op == "true" ? "false" : "true";
+
+            source1 +=
+@"
+public partial interface I1<T> where T : I1<T>
+{
+    abstract static bool operator " + matchingOp + @"(T x);
+}
+
+partial " + typeKeyword + @"
+    C
+{
+    public static bool operator " + matchingOp + @"(C x) => default;
+}
+";
+
+            var opName = UnaryOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c = module.GlobalNamespace.GetTypeMember("C");
+                var i1 = c.Interfaces().Single();
+                var m01 = i1.GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.UserDefinedOperator, cM01.MethodKind);
+                Assert.False(cM01.HasRuntimeSpecialName);
+                Assert.True(cM01.HasSpecialName);
+
+                Assert.Equal("System.Boolean C." + opName + "(C x)", cM01.ToTestDisplayString());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(m01, cM01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_07([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op, bool structure)
+        {
+            // Basic implicit implementation scenario, MethodImpl is emitted
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public partial interface I1<T> where T : I1<T>
+{
+    abstract static T operator " + op + @"(T x, int y);
+}
+
+#pragma warning disable CS0660, CS0661 // 'C1' defines operator == or operator != but does not override Object.Equals(object o)/Object.GetHashCode()
+
+partial " + typeKeyword + @"
+    C : I1<C>
+{
+    public static C operator " + op + @"(C x, int y) => default;
+}
+";
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1<T> where T : I1<T>
+{
+    abstract static T operator " + matchingOp + @"(T x, int y);
+}
+
+partial " + typeKeyword + @"
+    C
+{
+    public static C operator " + matchingOp + @"(C x, int y) => default;
+}
+";
+            }
+
+            var opName = BinaryOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c = module.GlobalNamespace.GetTypeMember("C");
+                var i1 = c.Interfaces().Single();
+                var m01 = i1.GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                Assert.Equal(matchingOp is null ? 1 : 2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.UserDefinedOperator, cM01.MethodKind);
+                Assert.False(cM01.HasRuntimeSpecialName);
+                Assert.True(cM01.HasSpecialName);
+
+                Assert.Equal("C C." + opName + "(C x, System.Int32 y)", cM01.ToTestDisplayString());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(m01, cM01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_08([CombinatorialValues("+", "-", "!", "~", "++", "--")] string op, bool structure)
+        {
+            // Basic explicit implementation scenario
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x);
+}
+
+" + typeKeyword + @"
+    C : I1
+{
+    static I1 I1.operator " + op + @"(I1 x) => default;
+}
+";
+
+            var opName = UnaryOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single();
+
+            Assert.Equal("default", node.ToString());
+            Assert.Equal("I1", model.GetTypeInfo(node).ConvertedType.ToTestDisplayString());
+
+            var declaredSymbol = model.GetDeclaredSymbol(node.FirstAncestorOrSelf<OperatorDeclarationSyntax>());
+            Assert.Equal("I1 C.I1." + opName + "(I1 x)", declaredSymbol.ToTestDisplayString());
+            Assert.DoesNotContain(opName, declaredSymbol.ContainingType.MemberNames);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, cM01.MethodKind);
+                Assert.False(cM01.HasRuntimeSpecialName);
+                Assert.False(cM01.HasSpecialName);
+
+                Assert.Equal("I1 C.I1." + opName + "(I1 x)", cM01.ToTestDisplayString());
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryTrueFalseOperator_08([CombinatorialValues("true", "false")] string op, bool structure)
+        {
+            // Basic explicit implementation scenario
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public partial interface I1
+{
+    abstract static bool operator " + op + @"(I1 x);
+}
+
+partial " + typeKeyword + @"
+    C : I1
+{
+    static bool I1.operator " + op + @"(I1 x) => default;
+}
+";
+            string matchingOp = op == "true" ? "false" : "true";
+
+            source1 +=
+@"
+public partial interface I1
+{
+    abstract static bool operator " + matchingOp + @"(I1 x);
+}
+
+partial " + typeKeyword + @"
+    C
+{
+    static bool I1.operator " + matchingOp + @"(I1 x) => default;
+}
+";
+
+            var opName = UnaryOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().First();
+
+            Assert.Equal("default", node.ToString());
+            Assert.Equal("System.Boolean", model.GetTypeInfo(node).ConvertedType.ToTestDisplayString());
+
+            var declaredSymbol = model.GetDeclaredSymbol(node.FirstAncestorOrSelf<OperatorDeclarationSyntax>());
+            Assert.Equal("System.Boolean C.I1." + opName + "(I1 x)", declaredSymbol.ToTestDisplayString());
+            Assert.DoesNotContain(opName, declaredSymbol.ContainingType.MemberNames);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers(opName).OfType<MethodSymbol>().Single();
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, cM01.MethodKind);
+                Assert.False(cM01.HasRuntimeSpecialName);
+                Assert.False(cM01.HasSpecialName);
+
+                Assert.Equal("System.Boolean C.I1." + opName + "(I1 x)", cM01.ToTestDisplayString());
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_08([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op, bool structure)
+        {
+            // Basic explicit implementation scenario
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public partial interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x, int y);
+}
+
+partial " + typeKeyword + @"
+    C : I1
+{
+    static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+";
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1
+{
+    abstract static I1 operator " + matchingOp + @"(I1 x, int y);
+}
+
+partial " + typeKeyword + @"
+    C
+{
+    static I1 I1.operator " + matchingOp + @"(I1 x, int y) => default;
+}
+";
+            }
+
+            var opName = BinaryOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().First();
+
+            Assert.Equal("default", node.ToString());
+            Assert.Equal("I1", model.GetTypeInfo(node).ConvertedType.ToTestDisplayString());
+
+            var declaredSymbol = model.GetDeclaredSymbol(node.FirstAncestorOrSelf<OperatorDeclarationSyntax>());
+            Assert.Equal("I1 C.I1." + opName + "(I1 x, System.Int32 y)", declaredSymbol.ToTestDisplayString());
+            Assert.DoesNotContain(opName, declaredSymbol.ContainingType.MemberNames);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers(opName).OfType<MethodSymbol>().Single();
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(matchingOp is null ? 1 : 2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, cM01.MethodKind);
+                Assert.False(cM01.HasRuntimeSpecialName);
+                Assert.False(cM01.HasSpecialName);
+
+                Assert.Equal("I1 C.I1." + opName + "(I1 x, System.Int32 y)", cM01.ToTestDisplayString());
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_09([CombinatorialValues("+", "-", "!", "~", "++", "--")] string op)
+        {
+            // Explicit implementation from base is treated as an implementation
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x);
+}
+
+public class C2 : I1
+{
+    static I1 I1.operator " + op + @"(I1 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            var opName = UnaryOperatorName(op);
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                     parseOptions: parseOptions,
+                                                     targetFramework: TargetFramework.NetCoreApp,
+                                                     references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+                var m01 = c3.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                var cM01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+
+                Assert.Equal("I1 C2.I1." + opName + "(I1 x)", cM01.ToTestDisplayString());
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryTrueFalseOperator_09([CombinatorialValues("true", "false")] string op)
+        {
+            // Explicit implementation from base is treated as an implementation
+
+            var source1 =
+@"
+public partial interface I1
+{
+    abstract static bool operator " + op + @"(I1 x);
+}
+
+public partial class C2 : I1
+{
+    static bool I1.operator " + op + @"(I1 x) => default;
+}
+";
+            string matchingOp = op == "true" ? "false" : "true";
+
+            source1 +=
+@"
+public partial interface I1
+{
+    abstract static bool operator " + matchingOp + @"(I1 x);
+}
+
+public partial class C2
+{
+    static bool I1.operator " + matchingOp + @"(I1 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            var opName = UnaryOperatorName(op);
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                     parseOptions: parseOptions,
+                                                     targetFramework: TargetFramework.NetCoreApp,
+                                                     references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+                var m01 = c3.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                var cM01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+
+                Assert.Equal("System.Boolean C2.I1." + opName + "(I1 x)", cM01.ToTestDisplayString());
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_09([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            // Explicit implementation from base is treated as an implementation
+
+            var source1 =
+@"
+public partial interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x, int y);
+}
+
+public partial class C2 : I1
+{
+    static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+";
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1
+{
+    abstract static I1 operator " + matchingOp + @"(I1 x, int y);
+}
+
+public partial class C2
+{
+    static I1 I1.operator " + matchingOp + @"(I1 x, int y) => default;
+}
+";
+            }
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            var opName = BinaryOperatorName(op);
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                     parseOptions: parseOptions,
+                                                     targetFramework: TargetFramework.NetCoreApp,
+                                                     references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+                var m01 = c3.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                var cM01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+
+                Assert.Equal("I1 C2.I1." + opName + "(I1 x, System.Int32 y)", cM01.ToTestDisplayString());
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_10([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op)
+        {
+            // Implicit implementation is considered only for types implementing interface in source.
+            // In metadata, only explicit implementations are considered
+
+            var opName = UnaryOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        class I1 " + opName + @" (
+            class I1 x
+        ) cil managed 
+    {
+    }
+}
+
+.class public auto ansi beforefieldinit C1
+    extends System.Object
+    implements I1
+{
+    .method private hidebysig
+        static class I1 I1." + opName + @" (class I1 x) cil managed 
+    {
+        .override method class I1 I1::" + opName + @"(class I1)
+
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+
+    .method public hidebysig static
+        specialname class I1 " + opName + @" (class I1 x) cil managed 
+    {
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    }
+}
+
+.class public auto ansi beforefieldinit C2
+    extends C1
+    implements I1
+{
+    .method public hidebysig static
+        specialname class I1 " + opName + @" (class I1 x) cil managed 
+    {
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void C1::.ctor()
+        IL_0006: ret
+    } // end of method C2::.ctor
+} // end of class C2
+";
+            var source1 =
+@"
+public class C3 : C2
+{
+}
+
+public class C4 : C1, I1
+{
+}
+
+public class C5 : C2, I1
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal(MethodKind.UserDefinedOperator, m01.MethodKind);
+            Assert.Equal(MethodKind.UserDefinedOperator, c1.GetMember<MethodSymbol>(opName).MethodKind);
+
+            var c1M01 = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+            Assert.Equal("I1 C1.I1." + opName + "(I1 x)", c1M01.ToTestDisplayString());
+            Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01.MethodKind);
+            Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+
+            var c2 = compilation1.GlobalNamespace.GetTypeMember("C2");
+            Assert.Same(c1M01, c2.FindImplementationForInterfaceMember(m01));
+
+            var c3 = compilation1.GlobalNamespace.GetTypeMember("C3");
+            Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+
+            var c4 = compilation1.GlobalNamespace.GetTypeMember("C4");
+            Assert.Same(c1M01, c4.FindImplementationForInterfaceMember(m01));
+
+            var c5 = compilation1.GlobalNamespace.GetTypeMember("C5");
+
+            var c2M01 = (MethodSymbol)c5.FindImplementationForInterfaceMember(m01);
+            Assert.Equal("I1 C2." + opName + "(I1 x)", c2M01.ToTestDisplayString());
+            Assert.Equal(MethodKind.UserDefinedOperator, c2M01.MethodKind);
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_10([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            // Implicit implementation is considered only for types implementing interface in source.
+            // In metadata, only explicit implementations are considered
+
+            var opName = BinaryOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        class I1 " + opName + @" (
+            class I1 x,
+            int32 y
+        ) cil managed 
+    {
+    }
+}
+
+.class public auto ansi beforefieldinit C1
+    extends System.Object
+    implements I1
+{
+    .method private hidebysig
+        static class I1 I1." + opName + @" (class I1 x, int32 y) cil managed 
+    {
+        .override method class I1 I1::" + opName + @"(class I1, int32)
+
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+
+    .method public hidebysig static
+        specialname class I1 " + opName + @" (class I1 x, int32 y) cil managed 
+    {
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    }
+}
+
+.class public auto ansi beforefieldinit C2
+    extends C1
+    implements I1
+{
+    .method public hidebysig static
+        specialname class I1 " + opName + @" (class I1 x, int32 y) cil managed 
+    {
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void C1::.ctor()
+        IL_0006: ret
+    } // end of method C2::.ctor
+} // end of class C2
+";
+            var source1 =
+@"
+public class C3 : C2
+{
+}
+
+public class C4 : C1, I1
+{
+}
+
+public class C5 : C2, I1
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal(MethodKind.UserDefinedOperator, m01.MethodKind);
+            Assert.Equal(MethodKind.UserDefinedOperator, c1.GetMember<MethodSymbol>(opName).MethodKind);
+
+            var c1M01 = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+            Assert.Equal("I1 C1.I1." + opName + "(I1 x, System.Int32 y)", c1M01.ToTestDisplayString());
+            Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01.MethodKind);
+            Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+
+            var c2 = compilation1.GlobalNamespace.GetTypeMember("C2");
+            Assert.Same(c1M01, c2.FindImplementationForInterfaceMember(m01));
+
+            var c3 = compilation1.GlobalNamespace.GetTypeMember("C3");
+            Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+
+            var c4 = compilation1.GlobalNamespace.GetTypeMember("C4");
+            Assert.Same(c1M01, c4.FindImplementationForInterfaceMember(m01));
+
+            var c5 = compilation1.GlobalNamespace.GetTypeMember("C5");
+
+            var c2M01 = (MethodSymbol)c5.FindImplementationForInterfaceMember(m01);
+            Assert.Equal("I1 C2." + opName + "(I1 x, System.Int32 y)", c2M01.ToTestDisplayString());
+            Assert.Equal(MethodKind.UserDefinedOperator, c2M01.MethodKind);
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_11([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op)
+        {
+            // Ignore invalid metadata (non-abstract static virtual method). 
+
+            var opName = UnaryOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname virtual
+        static class I1 " + opName + @" (
+            class I1 x
+        ) cil managed 
+    {
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+}
+";
+
+            var source1 =
+@"
+public class C1 : I1
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i1 = c1.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal(MethodKind.UserDefinedOperator, m01.MethodKind);
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics();
+
+            var source2 =
+@"
+public class C1 : I1
+{
+    static I1 I1.operator " + op + @"(I1 x) => default;
+}
+";
+
+            var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation2.VerifyEmitDiagnostics(
+                // (4,27): error CS0539: 'C1.operator ~(I1)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static I1 I1.operator ~(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("C1.operator " + op + "(I1)").WithLocation(4, 27)
+                );
+
+            c1 = compilation2.GlobalNamespace.GetTypeMember("C1");
+            m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal("I1 I1." + opName + "(I1 x)", m01.ToTestDisplayString());
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_11([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            // Ignore invalid metadata (non-abstract static virtual method). 
+
+            var opName = BinaryOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname virtual
+        static class I1 " + opName + @" (
+            class I1 x,
+            int32 y
+        ) cil managed 
+    {
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+}
+";
+
+            var source1 =
+@"
+public class C1 : I1
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i1 = c1.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal(MethodKind.UserDefinedOperator, m01.MethodKind);
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics();
+
+            var source2 =
+@"
+public class C1 : I1
+{
+    static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+";
+
+            var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation2.VerifyEmitDiagnostics(
+                // (4,27): error CS0539: 'C1.operator <(I1, int)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static I1 I1.operator <(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, op).WithArguments("C1.operator " + op + "(I1, int)").WithLocation(4, 27)
+                );
+
+            c1 = compilation2.GlobalNamespace.GetTypeMember("C1");
+            m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal("I1 I1." + opName + "(I1 x, System.Int32 y)", m01.ToTestDisplayString());
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_12([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op)
+        {
+            // Ignore invalid metadata (default interface implementation for a static method)
+
+            var opName = UnaryOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        class I1 " + opName + @" (
+            class I1 x
+        ) cil managed 
+    {
+    }
+}
+.class interface public auto ansi abstract I2
+    implements I1
+{
+    .method private hidebysig
+        static class I1 I1." + opName + @" (class I1 x) cil managed 
+    {
+        .override method class I1 I1::" + opName + @"(class I1)
+
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+}
+";
+
+            var source1 =
+@"
+public class C1 : I2
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics(
+                // (2,19): error CS0535: 'C1' does not implement interface member 'I1.operator ~(I1)'
+                // public class C1 : I2
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2").WithArguments("C1", "I1.operator " + op + "(I1)").WithLocation(2, 19)
+                );
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i2 = c1.Interfaces().Single();
+            var i1 = i2.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal(MethodKind.UserDefinedOperator, m01.MethodKind);
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01));
+
+            var i2M01 = i2.GetMembers().OfType<MethodSymbol>().Single();
+            Assert.Same(m01, i2M01.ExplicitInterfaceImplementations.Single());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_12([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            // Ignore invalid metadata (default interface implementation for a static method)
+
+            var opName = BinaryOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        class I1 " + opName + @" (
+            class I1 x,
+            int32 y
+        ) cil managed 
+    {
+    }
+}
+.class interface public auto ansi abstract I2
+    implements I1
+{
+    .method private hidebysig
+        static class I1 I1." + opName + @" (class I1 x, int32 y) cil managed 
+    {
+        .override method class I1 I1::" + opName + @"(class I1, int32)
+
+        IL_0000: ldnull
+        IL_0001: ret
+    }
+}
+";
+
+            var source1 =
+@"
+public class C1 : I2
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics(
+                // (2,19): error CS0535: 'C1' does not implement interface member 'I1.operator /(I1, int)'
+                // public class C1 : I2
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2").WithArguments("C1", "I1.operator " + op + "(I1, int)").WithLocation(2, 19)
+                );
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i2 = c1.Interfaces().Single();
+            var i1 = i2.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal(MethodKind.UserDefinedOperator, m01.MethodKind);
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01));
+
+            var i2M01 = i2.GetMembers().OfType<MethodSymbol>().Single();
+            Assert.Same(m01, i2M01.ExplicitInterfaceImplementations.Single());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_13([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            // A forwarding method is added for an implicit implementation declared in base class. 
+
+            var source1 =
+@"
+public partial interface I1<T> where T : I1<T>
+{
+    abstract static T operator " + op + @"(T x, C1 y);
+}
+
+#pragma warning disable CS0660, CS0661 // 'C1' defines operator == or operator != but does not override Object.Equals(object o)/Object.GetHashCode()
+
+public partial class C1
+{
+    public static C2 operator " + op + @"(C2 x, C1 y) => default;
+}
+
+public class C2 : C1, I1<C2>
+{
+}
+";
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1<T>
+{
+    abstract static T operator " + matchingOp + @"(T x, C1 y);
+}
+
+public partial class C1
+{
+    public static C2 operator " + matchingOp + @"(C2 x, C1 y) => default;
+}
+";
+            }
+
+            var opName = BinaryOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var i1 = c2.Interfaces().Single();
+                var m01 = i1.GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                var c2M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01.MethodKind);
+                    Assert.False(c2M01.HasRuntimeSpecialName);
+                    Assert.False(c2M01.HasSpecialName);
+
+                    Assert.Equal("C2 C2.I1<C2>." + opName + "(C2 x, C1 y)", c2M01.ToTestDisplayString());
+                    Assert.Equal(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                    var c1M01 = module.GlobalNamespace.GetMember<MethodSymbol>("C1." + opName);
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.False(c1M01.IsMetadataVirtual());
+                    Assert.False(c1M01.IsMetadataFinal);
+                    Assert.False(c1M01.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.UserDefinedOperator, c1M01.MethodKind);
+                    Assert.False(c1M01.HasRuntimeSpecialName);
+                    Assert.True(c1M01.HasSpecialName);
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.Equal(MethodKind.UserDefinedOperator, c2M01.MethodKind);
+                    Assert.False(c2M01.HasRuntimeSpecialName);
+                    Assert.True(c2M01.HasSpecialName);
+
+                    Assert.Equal("C2 C1." + opName + "(C2 x, C1 y)", c2M01.ToTestDisplayString());
+                    Assert.Empty(c2M01.ExplicitInterfaceImplementations);
+                }
+            }
+
+            verifier.VerifyIL("C2.I1<C2>." + opName + "(C2, C1)",
+@"
+{
+  // Code size        8 (0x8)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  call       ""C2 C1." + opName + @"(C2, C1)""
+  IL_0007:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_14([CombinatorialValues("+", "-", "!", "~", "++", "--")] string op)
+        {
+            // A forwarding method is added for an implicit implementation with modopt mismatch. 
+
+            var opName = UnaryOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1`1<(class I1`1<!T>) T>
+{
+    // Methods
+    .method public hidebysig specialname abstract virtual static 
+        !T modopt(I1`1) " + opName + @" (
+            !T x
+        ) cil managed 
+    {
+    }
+} 
+";
+
+            var source1 =
+@"
+class C1 : I1<C1>
+{
+    public static C1 operator " + op + @"(C1 x) => default;
+}
+
+class C2 : I1<C2>
+{
+    static C2 I1<C2>.operator " + op + @"(C2 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c1 = module.GlobalNamespace.GetTypeMember("C1");
+                var m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                var c1M01 = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+                Assert.False(c1M01.IsMetadataVirtual());
+                Assert.False(c1M01.IsMetadataFinal);
+                Assert.False(c1M01.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01.MethodKind);
+                    Assert.Equal("C1 modopt(I1<>) C1.I1<C1>." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+                    Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+
+                    c1M01 = module.GlobalNamespace.GetMember<MethodSymbol>("C1." + opName);
+                    Assert.Equal("C1 C1." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.False(c1M01.IsMetadataVirtual());
+                    Assert.False(c1M01.IsMetadataFinal);
+                    Assert.False(c1M01.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.UserDefinedOperator, c1M01.MethodKind);
+
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.Equal(MethodKind.UserDefinedOperator, c1M01.MethodKind);
+                    Assert.Equal("C1 C1." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+                var c2M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01.MethodKind);
+
+                Assert.Equal("C2 modopt(I1<>) C2.I1<C2>." + opName + "(C2 x)", c2M01.ToTestDisplayString());
+                Assert.Equal(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                Assert.Same(c2M01, c2.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Single());
+            }
+
+            verifier.VerifyIL("C1.I1<C1>." + opName + "(C1)",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""C1 C1." + opName + @"(C1)""
+  IL_0006:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryTrueFalseOperator_14([CombinatorialValues("true", "false")] string op)
+        {
+            // A forwarding method is added for an implicit implementation with modopt mismatch. 
+
+            var opName = UnaryOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1`1<(class I1`1<!T>) T>
+{
+    // Methods
+    .method public hidebysig specialname abstract virtual static 
+        bool modopt(I1`1) " + opName + @" (
+            !T x
+        ) cil managed 
+    {
+    }
+} 
+";
+
+            var source1 =
+@"
+class C1 : I1<C1>
+{
+    public static bool operator " + op + @"(C1 x) => default;
+    public static bool operator " + (op == "true" ? "false" : "true") + @"(C1 x) => default;
+}
+
+class C2 : I1<C2>
+{
+    static bool I1<C2>.operator " + op + @"(C2 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c1 = module.GlobalNamespace.GetTypeMember("C1");
+                var m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                var c1M01 = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+                Assert.False(c1M01.IsMetadataVirtual());
+                Assert.False(c1M01.IsMetadataFinal);
+                Assert.False(c1M01.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01.MethodKind);
+                    Assert.Equal("System.Boolean modopt(I1<>) C1.I1<C1>." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+                    Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+
+                    c1M01 = module.GlobalNamespace.GetMember<MethodSymbol>("C1." + opName);
+                    Assert.Equal("System.Boolean C1." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.False(c1M01.IsMetadataVirtual());
+                    Assert.False(c1M01.IsMetadataFinal);
+                    Assert.False(c1M01.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.UserDefinedOperator, c1M01.MethodKind);
+
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.Equal(MethodKind.UserDefinedOperator, c1M01.MethodKind);
+                    Assert.Equal("System.Boolean C1." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+                var c2M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01.MethodKind);
+
+                Assert.Equal("System.Boolean modopt(I1<>) C2.I1<C2>." + opName + "(C2 x)", c2M01.ToTestDisplayString());
+                Assert.Equal(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                Assert.Same(c2M01, c2.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Single());
+            }
+
+            verifier.VerifyIL("C1.I1<C1>." + opName + "(C1)",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""bool C1." + opName + @"(C1)""
+  IL_0006:  ret
+}
+");
+        }
+
+        private static string MatchingBinaryOperator(string op)
+        {
+            return op switch { "<" => ">", ">" => "<", "<=" => ">=", ">=" => "<=", "==" => "!=", "!=" => "==", _ => null };
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_14([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            // A forwarding method is added for an implicit implementation with modopt mismatch. 
+
+            var opName = BinaryOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1`1<(class I1`1<!T>) T>
+{
+    // Methods
+    .method public hidebysig specialname abstract virtual static 
+        !T modopt(I1`1) " + opName + @" (
+            !T x,
+            int32 y
+        ) cil managed 
+    {
+    }
+} 
+";
+            string matchingOp = MatchingBinaryOperator(op);
+            string additionalMethods = "";
+
+            if (matchingOp is object)
+            {
+                additionalMethods =
+@"
+    public static C1 operator " + matchingOp + @"(C1 x, int y) => default;
+";
+            }
+
+            var source1 =
+@"
+#pragma warning disable CS0660, CS0661 // 'C1' defines operator == or operator != but does not override Object.Equals(object o)/Object.GetHashCode()
+
+class C1 : I1<C1>
+{
+    public static C1 operator " + op + @"(C1 x, int y) => default;
+" + additionalMethods + @"
+}
+
+class C2 : I1<C2>
+{
+    static C2 I1<C2>.operator " + op + @"(C2 x, int y) => default;
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c1 = module.GlobalNamespace.GetTypeMember("C1");
+                var m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                var c1M01 = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+                Assert.False(c1M01.IsMetadataVirtual());
+                Assert.False(c1M01.IsMetadataFinal);
+                Assert.False(c1M01.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01.MethodKind);
+                    Assert.Equal("C1 modopt(I1<>) C1.I1<C1>." + opName + "(C1 x, System.Int32 y)", c1M01.ToTestDisplayString());
+                    Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+
+                    c1M01 = module.GlobalNamespace.GetMember<MethodSymbol>("C1." + opName);
+                    Assert.Equal("C1 C1." + opName + "(C1 x, System.Int32 y)", c1M01.ToTestDisplayString());
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.False(c1M01.IsMetadataVirtual());
+                    Assert.False(c1M01.IsMetadataFinal);
+                    Assert.False(c1M01.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.UserDefinedOperator, c1M01.MethodKind);
+
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.Equal(MethodKind.UserDefinedOperator, c1M01.MethodKind);
+                    Assert.Equal("C1 C1." + opName + "(C1 x, System.Int32 y)", c1M01.ToTestDisplayString());
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+                var c2M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01.MethodKind);
+
+                Assert.Equal("C2 modopt(I1<>) C2.I1<C2>." + opName + "(C2 x, System.Int32 y)", c2M01.ToTestDisplayString());
+                Assert.Equal(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                Assert.Same(c2M01, c2.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Single());
+            }
+
+            verifier.VerifyIL("C1.I1<C1>." + opName + "(C1, int)",
+@"
+{
+  // Code size        8 (0x8)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  call       ""C1 C1." + opName + @"(C1, int)""
+  IL_0007:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticUnaryOperator_15([CombinatorialValues("+", "-", "!", "~", "++", "--")] string op)
+        {
+            // A forwarding method isn't created if base class implements interface exactly the same way. 
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x);
+}
+
+public partial class C2 : I1
+{
+    static I1 I1.operator " + op + @"(I1 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            var opName = UnaryOperatorName(op);
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.RegularPreview, TestOptions.Regular9 })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+
+                var m02 = c3.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                var c2M02 = c3.BaseType().GetMembers("I1." + opName).OfType<MethodSymbol>().Single();
+                Assert.Equal("I1 C2.I1." + opName + "(I1 x)", c2M02.ToTestDisplayString());
+                Assert.Same(c2M02, c3.FindImplementationForInterfaceMember(m02));
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticUnaryTrueFalseOperator_15()
+        {
+            // A forwarding method isn't created if base class implements interface exactly the same way. 
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static bool operator true(I1 x);
+    abstract static bool operator false(I1 x);
+}
+
+public partial class C2 : I1
+{
+    static bool I1.operator true(I1 x) => default;
+    static bool I1.operator false(I1 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.RegularPreview, TestOptions.Regular9 })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+
+                var m01 = c3.Interfaces().Single().GetMembers("op_True").OfType<MethodSymbol>().Single();
+                var m02 = c3.Interfaces().Single().GetMembers("op_False").OfType<MethodSymbol>().Single();
+
+                var c2M01 = c3.BaseType().GetMembers("I1.op_True").OfType<MethodSymbol>().Single();
+                Assert.Equal("System.Boolean C2.I1.op_True(I1 x)", c2M01.ToTestDisplayString());
+                Assert.Same(c2M01, c3.FindImplementationForInterfaceMember(m01));
+
+                var c2M02 = c3.BaseType().GetMembers("I1.op_False").OfType<MethodSymbol>().Single();
+                Assert.Equal("System.Boolean C2.I1.op_False(I1 x)", c2M02.ToTestDisplayString());
+                Assert.Same(c2M02, c3.FindImplementationForInterfaceMember(m02));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_15([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            // A forwarding method isn't created if base class implements interface exactly the same way. 
+
+            var source1 =
+@"
+public partial interface I1<T> where T : I1<T>
+{
+    abstract static T operator " + op + @"(T x, C1 y);
+    abstract static T operator " + op + @"(T x, C2 y);
+}
+
+#pragma warning disable CS0660, CS0661 // 'C1' defines operator == or operator != but does not override Object.Equals(object o)/Object.GetHashCode()
+
+public partial class C1
+{
+    public static C2 operator " + op + @"(C2 x, C1 y) => default;
+}
+
+public partial class C2 : C1, I1<C2>
+{
+    static C2 I1<C2>.operator " + op + @"(C2 x, C2 y) => default;
+}
+";
+
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1<T>
+{
+    abstract static T operator " + matchingOp + @"(T x, C1 y);
+    abstract static T operator " + matchingOp + @"(T x, C2 y);
+}
+
+public partial class C1
+{
+    public static C2 operator " + matchingOp + @"(C2 x, C1 y) => default;
+}
+
+public partial class C2
+{
+    static C2 I1<C2>.operator " + matchingOp + @"(C2 x, C2 y) => default;
+}
+";
+            }
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1<C2>
+{
+}
+";
+
+            var opName = BinaryOperatorName(op);
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.RegularPreview, TestOptions.Regular9 })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+
+                var m01 = c3.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().First();
+
+                var c1M01 = c3.BaseType().BaseType().GetMember<MethodSymbol>(opName);
+                Assert.Equal("C2 C1." + opName + "(C2 x, C1 y)", c1M01.ToTestDisplayString());
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+                Assert.False(c1M01.IsMetadataVirtual());
+                Assert.False(c1M01.IsMetadataFinal);
+                Assert.False(c1M01.IsMetadataNewSlot());
+
+                Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+
+                if (c1M01.ContainingModule is PEModuleSymbol)
+                {
+                    var c2M01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+                    Assert.Equal("C2 C2.I1<C2>." + opName + "(C2 x, C1 y)", c2M01.ToTestDisplayString());
+                    Assert.Equal(m01, c2M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+                }
+
+                var m02 = c3.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().ElementAt(1);
+
+                var c2M02 = c3.BaseType().GetMembers("I1<C2>." + opName).OfType<MethodSymbol>().First();
+                Assert.Equal("C2 C2.I1<C2>." + opName + "(C2 x, C2 y)", c2M02.ToTestDisplayString());
+                Assert.Same(c2M02, c3.FindImplementationForInterfaceMember(m02));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_16([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            // A new implicit implementation is properly considered.
+
+            var source1 =
+@"
+public partial interface I1<T> where T : I1<T>
+{
+    abstract static T operator " + op + @"(T x, C1 y);
+}
+
+#pragma warning disable CS0660, CS0661 // 'C1' defines operator == or operator != but does not override Object.Equals(object o)/Object.GetHashCode()
+
+public partial class C1 : I1<C2>
+{
+    public static C2 operator " + op + @"(C2 x, C1 y) => default;
+}
+
+public partial class C2 : C1
+{
+    public static C2 operator " + op + @"(C2 x, C1 y) => default;
+}
+";
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1<T>
+{
+    abstract static T operator " + matchingOp + @"(T x, C1 y);
+}
+
+public partial class C1 : I1<C2>
+{
+    public static C2 operator " + matchingOp + @"(C2 x, C1 y) => default;
+}
+
+public partial class C2 : C1
+{
+    public static C2 operator " + matchingOp + @"(C2 x, C1 y) => default;
+}
+";
+            }
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1<C2>
+{
+}
+";
+
+            var opName = BinaryOperatorName(op);
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                     parseOptions: parseOptions,
+                                                     targetFramework: TargetFramework.NetCoreApp,
+                                                     references: new[] { reference });
+                    var verifier = CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+                    verifier.VerifyIL("C3.I1<C2>." + opName + "(C2, C1)",
+@"
+{
+  // Code size        8 (0x8)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  call       ""C2 C2." + opName + @"(C2, C1)""
+  IL_0007:  ret
+}
+");
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                var m01 = c3.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                var c2M01 = c3.BaseType().GetMember<MethodSymbol>(opName);
+                Assert.Equal("C2 C2." + opName + "(C2 x, C1 y)", c2M01.ToTestDisplayString());
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+
+                Assert.Empty(c2M01.ExplicitInterfaceImplementations);
+
+                if (module is PEModuleSymbol)
+                {
+                    var c3M01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+                    Assert.Equal("C2 C3.I1<C2>." + opName + "(C2 x, C1 y)", c3M01.ToTestDisplayString());
+                    Assert.Equal(m01, c3M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Same(c2M01, c3.FindImplementationForInterfaceMember(m01));
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_18([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<", ">", "<=", ">=", "==", "!=")] string op, bool genericFirst)
+        {
+            // An "ambiguity" in implicit implementation declared in generic base class plus interface is generic too.
+
+            var generic =
+@"
+    public static C1<T, U> operator " + op + @"(C1<T, U> x, U y) => default;
+";
+            var nonGeneric =
+@"
+    public static C1<T, U> operator " + op + @"(C1<T, U> x, int y) => default;
+";
+            var source1 =
+@"
+public partial interface I1<T, U> where T : I1<T, U>
+{
+    abstract static T operator " + op + @"(T x, U y);
+}
+
+#pragma warning disable CS0660, CS0661 // 'C1' defines operator == or operator != but does not override Object.Equals(object o)/Object.GetHashCode()
+
+public partial class C1<T, U> : I1<C1<T, U>, U>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1<T, U>
+{
+    abstract static T operator " + matchingOp + @"(T x, U y);
+}
+
+public partial class C1<T, U>
+{
+    public static C1<T, U> operator " + matchingOp + @"(C1<T, U> x, U y) => default;
+    public static C1<T, U> operator " + matchingOp + @"(C1<T, U> x, int y) => default;
+}
+";
+            }
+
+            var opName = BinaryOperatorName(op);
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            compilation1.VerifyDiagnostics();
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count());
+
+            var source2 =
+@"
+public class C2 : C1<int, int>, I1<C1<int, int>, int>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("C1<T, U> C1<T, U>." + opName + "(C1<T, U> x, U y)", c1M01.OriginalDefinition.ToTestDisplayString());
+
+                var baseI1M01 = c2.BaseType().FindImplementationForInterfaceMember(m01);
+                Assert.Equal("C1<T, U> C1<T, U>." + opName + "(C1<T, U> x, U y)", baseI1M01.OriginalDefinition.ToTestDisplayString());
+
+                Assert.Equal(c1M01, baseI1M01);
+
+                if (c1M01.OriginalDefinition.ContainingModule is PEModuleSymbol)
+                {
+                    Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_20([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<", ">", "<=", ">=", "==", "!=")] string op, bool genericFirst)
+        {
+            // Same as ImplementAbstractStaticBinaryOperator_18 only implementation is explicit in source.
+
+            var generic =
+@"
+    static C1<T, U> I1<C1<T, U>, U>.operator " + op + @"(C1<T, U> x, U y) => default;
+";
+            var nonGeneric =
+@"
+    public static C1<T, U> operator " + op + @"(C1<T, U> x, int y) => default;
+";
+            var source1 =
+@"
+public partial interface I1<T, U> where T : I1<T, U>
+{
+    abstract static T operator " + op + @"(T x, U y);
+}
+
+#pragma warning disable CS0660, CS0661 // 'C1' defines operator == or operator != but does not override Object.Equals(object o)/Object.GetHashCode()
+
+public partial class C1<T, U> : I1<C1<T, U>, U>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1<T, U> where T : I1<T, U>
+{
+    abstract static T operator " + matchingOp + @"(T x, U y);
+}
+
+public partial class C1<T, U> : I1<C1<T, U>, U>
+{
+    public static C1<T, U> operator " + matchingOp + @"(C1<T, U> x, int y) => default;
+    static C1<T, U> I1<C1<T, U>, U>.operator " + matchingOp + @"(C1<T, U> x, U y) => default;
+}
+";
+            }
+
+            var opName = BinaryOperatorName(op);
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            compilation1.VerifyDiagnostics();
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count());
+
+            var source2 =
+@"
+public class C2 : C1<int, int>, I1<C1<int, int>, int>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("C1<T, U> C1<T, U>.I1<C1<T, U>, U>." + opName + "(C1<T, U> x, U y)", c1M01.OriginalDefinition.ToTestDisplayString());
+
+                Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c1M01, c2.BaseType().FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticBinaryOperator_22([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<", ">", "<=", ">=", "==", "!=")] string op, bool genericFirst)
+        {
+            // Same as ImplementAbstractStaticMethod_18 only implicit implementation is in an intermediate base.
+
+            var generic =
+@"
+    public static C11<T, U> operator " + op + @"(C11<T, U> x, C1<T, U> y) => default;
+";
+            var nonGeneric =
+@"
+    public static C11<T, U> operator " + op + @"(C11<T, int> x, C1<T, U> y) => default;
+";
+            var source1 =
+@"
+public partial interface I1<T, U> where T : I1<T, U>
+{
+    abstract static T operator " + op + @"(T x, U y);
+}
+
+#pragma warning disable CS0660, CS0661 // 'C1' defines operator == or operator != but does not override Object.Equals(object o)/Object.GetHashCode()
+
+public partial class C1<T, U>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+
+public class C11<T, U> : C1<T, U>, I1<C11<T, U>, C1<T, U>>
+{
+}
+";
+            string matchingOp = MatchingBinaryOperator(op);
+
+            if (matchingOp is object)
+            {
+                source1 +=
+@"
+public partial interface I1<T, U>
+{
+    abstract static T operator " + matchingOp + @"(T x, U y);
+}
+
+public partial class C1<T, U>
+{
+    public static C11<T, U> operator " + matchingOp + @"(C11<T, U> x, C1<T, U> y) => default;
+    public static C11<T, U> operator " + matchingOp + @"(C11<T, int> x, C1<T, U> y) => default;
+}
+";
+            }
+
+            var opName = BinaryOperatorName(op);
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            compilation1.VerifyDiagnostics();
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count());
+
+            var source2 =
+@"
+public class C2 : C11<int, int>, I1<C11<int, int>, C1<int, int>>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                var expectedDisplay = m01.ContainingModule is PEModuleSymbol ? "C11<T, U> C11<T, U>.I1<C11<T, U>, C1<T, U>>." + opName + "(C11<T, U> x, C1<T, U> y)" : "C11<T, U> C1<T, U>." + opName + "(C11<T, U> x, C1<T, U> y)";
+                Assert.Equal(expectedDisplay, c1M01.OriginalDefinition.ToTestDisplayString());
+
+                var baseI1M01 = c2.BaseType().FindImplementationForInterfaceMember(m01);
+                Assert.Equal(expectedDisplay, baseI1M01.OriginalDefinition.ToTestDisplayString());
+
+                Assert.Equal(c1M01, baseI1M01);
+
+                if (c1M01.OriginalDefinition.ContainingModule is PEModuleSymbol)
+                {
+                    Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ExplicitImplementationModifiersUnaryOperator_01([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x);
+}
+
+class
+    C1 : I1
+{
+    static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C2 : I1
+{
+    private static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C3 : I1
+{
+    protected static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C4 : I1
+{
+    internal static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C5 : I1
+{
+    protected internal static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C6 : I1
+{
+    private protected static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C7 : I1
+{
+    public static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C8 : I1
+{
+    static partial I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C9 : I1
+{
+    async static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C10 : I1
+{
+    unsafe static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C11 : I1
+{
+    static readonly I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C12 : I1
+{
+    extern static I1 I1.operator " + op + @"(I1 x);
+}
+
+class
+    C13 : I1
+{
+    abstract static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C14 : I1
+{
+    virtual static I1 I1.operator " + op + @"(I1 x) => default;
+}
+
+class
+    C15 : I1
+{
+    sealed static I1 I1.operator " + op + @"(I1 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll.WithAllowUnsafe(true),
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+
+            Assert.Equal(Accessibility.Private, c1.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Single().DeclaredAccessibility);
+
+            compilation1.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.WRN_ExternMethodNoImplementation or (int)ErrorCode.ERR_OpTFRetType or (int)ErrorCode.ERR_OperatorNeedsMatch)).Verify(
+                // (16,35): error CS0106: The modifier 'private' is not valid for this item
+                //     private static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("private").WithLocation(16, 35),
+                // (22,37): error CS0106: The modifier 'protected' is not valid for this item
+                //     protected static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("protected").WithLocation(22, 37),
+                // (28,36): error CS0106: The modifier 'internal' is not valid for this item
+                //     internal static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("internal").WithLocation(28, 36),
+                // (34,46): error CS0106: The modifier 'protected internal' is not valid for this item
+                //     protected internal static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("protected internal").WithLocation(34, 46),
+                // (40,45): error CS0106: The modifier 'private protected' is not valid for this item
+                //     private protected static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("private protected").WithLocation(40, 45),
+                // (46,34): error CS0106: The modifier 'public' is not valid for this item
+                //     public static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("public").WithLocation(46, 34),
+                // (52,12): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     static partial I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(52, 12),
+                // (58,33): error CS0106: The modifier 'async' is not valid for this item
+                //     async static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("async").WithLocation(58, 33),
+                // (70,36): error CS0106: The modifier 'readonly' is not valid for this item
+                //     static readonly I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("readonly").WithLocation(70, 36),
+                // (82,36): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("abstract").WithLocation(82, 36),
+                // (88,35): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("virtual").WithLocation(88, 35),
+                // (94,34): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static I1 I1.operator !(I1 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("sealed").WithLocation(94, 34)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ExplicitImplementationModifiersBinaryOperator_01([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static I1 operator " + op + @"(I1 x, int y);
+}
+
+struct
+    C1 : I1
+{
+    static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C2 : I1
+{
+    private static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C3 : I1
+{
+    protected static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C4 : I1
+{
+    internal static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C5 : I1
+{
+    protected internal static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C6 : I1
+{
+    private protected static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C7 : I1
+{
+    public static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C8 : I1
+{
+    static partial I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C9 : I1
+{
+    async static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C10 : I1
+{
+    unsafe static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C11 : I1
+{
+    static readonly I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C12 : I1
+{
+    extern static I1 I1.operator " + op + @"(I1 x, int y);
+}
+
+struct
+    C13 : I1
+{
+    abstract static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C14 : I1
+{
+    virtual static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+
+struct
+    C15 : I1
+{
+    sealed static I1 I1.operator " + op + @"(I1 x, int y) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll.WithAllowUnsafe(true),
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+
+            Assert.Equal(Accessibility.Private, c1.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Single().DeclaredAccessibility);
+
+            compilation1.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.WRN_ExternMethodNoImplementation or (int)ErrorCode.ERR_OperatorNeedsMatch)).Verify(
+                // (16,35): error CS0106: The modifier 'private' is not valid for this item
+                //     private static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("private").WithLocation(16, 35),
+                // (22,37): error CS0106: The modifier 'protected' is not valid for this item
+                //     protected static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("protected").WithLocation(22, 37),
+                // (28,36): error CS0106: The modifier 'internal' is not valid for this item
+                //     internal static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("internal").WithLocation(28, 36),
+                // (34,46): error CS0106: The modifier 'protected internal' is not valid for this item
+                //     protected internal static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("protected internal").WithLocation(34, 46),
+                // (40,45): error CS0106: The modifier 'private protected' is not valid for this item
+                //     private protected static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("private protected").WithLocation(40, 45),
+                // (46,34): error CS0106: The modifier 'public' is not valid for this item
+                //     public static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("public").WithLocation(46, 34),
+                // (52,12): error CS0267: The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type.
+                //     static partial I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_PartialMisplaced, "partial").WithLocation(52, 12),
+                // (58,33): error CS0106: The modifier 'async' is not valid for this item
+                //     async static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("async").WithLocation(58, 33),
+                // (70,36): error CS0106: The modifier 'readonly' is not valid for this item
+                //     static readonly I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("readonly").WithLocation(70, 36),
+                // (82,36): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("abstract").WithLocation(82, 36),
+                // (88,35): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("virtual").WithLocation(88, 35),
+                // (94,34): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static I1 I1.operator ^(I1 x, int y) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, op).WithArguments("sealed").WithLocation(94, 34)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ExplicitInterfaceSpecifierErrorsUnaryOperator_01([CombinatorialValues("+", "-", "!", "~", "++", "--", "true", "false")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : struct
+{
+    abstract static I1<T> operator " + op + @"(I1<T> x);
+}
+
+class C1
+{
+    static I1<int> I1<int>.operator " + op + @"(I1<int> x) => default;
+}
+
+class C2 : I1<C2>
+{
+    static I1<C2> I1<C2>.operator " + op + @"(I1<C2> x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.GetDiagnostics().Where(d => d.Code is not ((int)ErrorCode.ERR_OpTFRetType or (int)ErrorCode.ERR_OperatorNeedsMatch)).Verify(
+                // (9,20): error CS0540: 'C1.I1<int>.operator -(I1<int>)': containing type does not implement interface 'I1<int>'
+                //     static I1<int> I1<int>.operator -(I1<int> x) => default;
+                Diagnostic(ErrorCode.ERR_ClassDoesntImplementInterface, "I1<int>").WithArguments("C1.I1<int>.operator " + op + "(I1<int>)", "I1<int>").WithLocation(9, 20),
+                // (12,7): error CS0453: The type 'C2' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                // class C2 : I1<C2>
+                Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, "C2").WithArguments("I1<T>", "T", "C2").WithLocation(12, 7),
+                // (14,19): error CS0453: The type 'C2' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                //     static I1<C2> I1<C2>.operator -(I1<C2> x) => default;
+                Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, "I1<C2>").WithArguments("I1<T>", "T", "C2").WithLocation(14, 19),
+                // (14,35): error CS0453: The type 'C2' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                //     static I1<C2> I1<C2>.operator -(I1<C2> x) => default;
+                Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, op).WithArguments("I1<T>", "T", "C2").WithLocation(14, 35),
+                // (14,44): error CS0453: The type 'C2' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                //     static I1<C2> I1<C2>.operator -(I1<C2> x) => default;
+                Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, "x").WithArguments("I1<T>", "T", "C2").WithLocation(14, 44 + op.Length - 1)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ExplicitInterfaceSpecifierErrorsBinaryOperator_01([CombinatorialValues("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "<", ">", "<=", ">=", "==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : class
+{
+    abstract static I1<T> operator " + op + @"(I1<T> x, int y);
+}
+
+struct C1
+{
+    static I1<string> I1<string>.operator " + op + @"(I1<string> x, int y) => default;
+}
+
+struct C2 : I1<C2>
+{
+    static I1<C2> I1<C2>.operator " + op + @"(I1<C2> x, int y) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_OperatorNeedsMatch).Verify(
+                // (9,23): error CS0540: 'C1.I1<string>.operator %(I1<string>, int)': containing type does not implement interface 'I1<string>'
+                //     static I1<string> I1<string>.operator %(I1<string> x, int y) => default;
+                Diagnostic(ErrorCode.ERR_ClassDoesntImplementInterface, "I1<string>").WithArguments("C1.I1<string>.operator " + op + "(I1<string>, int)", "I1<string>").WithLocation(9, 23),
+                // (12,8): error CS0452: The type 'C2' must be a reference type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                // struct C2 : I1<C2>
+                Diagnostic(ErrorCode.ERR_RefConstraintNotSatisfied, "C2").WithArguments("I1<T>", "T", "C2").WithLocation(12, 8),
+                // (14,19): error CS0452: The type 'C2' must be a reference type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                //     static I1<C2> I1<C2>.operator %(I1<C2> x, int y) => default;
+                Diagnostic(ErrorCode.ERR_RefConstraintNotSatisfied, "I1<C2>").WithArguments("I1<T>", "T", "C2").WithLocation(14, 19),
+                // (14,35): error CS0452: The type 'C2' must be a reference type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                //     static I1<C2> I1<C2>.operator %(I1<C2> x, int y) => default;
+                Diagnostic(ErrorCode.ERR_RefConstraintNotSatisfied, op).WithArguments("I1<T>", "T", "C2").WithLocation(14, 35),
+                // (14,44): error CS0452: The type 'C2' must be a reference type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                //     static I1<C2> I1<C2>.operator %(I1<C2> x, int y) => default;
+                Diagnostic(ErrorCode.ERR_RefConstraintNotSatisfied, "x").WithArguments("I1<T>", "T", "C2").WithLocation(14, 44 + op.Length - 1)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticProperty_01(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C1 : I1
+{}
+
+" + typeKeyword + @"
+    C2 : I1
+{
+    public int M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C3 : I1
+{
+    static int M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C4 : I1
+{
+    int I1.M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C5 : I1
+{
+    public static long M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C6 : I1
+{
+    static long I1.M01 { get; set; }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,10): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                //     C1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01").WithLocation(8, 10),
+                // (12,10): error CS8928: 'C2' does not implement static interface member 'I1.M01'. 'C2.M01' cannot implement the interface member because it is not static.
+                //     C2 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotStatic, "I1").WithArguments("C2", "I1.M01", "C2.M01").WithLocation(12, 10),
+                // (18,10): error CS0737: 'C3' does not implement interface member 'I1.M01'. 'C3.M01' cannot implement an interface member because it is not public.
+                //     C3 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "I1").WithArguments("C3", "I1.M01", "C3.M01").WithLocation(18, 10),
+                // (24,10): error CS0535: 'C4' does not implement interface member 'I1.M01'
+                //     C4 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C4", "I1.M01").WithLocation(24, 10),
+                // (26,12): error CS0539: 'C4.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     int I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C4.M01").WithLocation(26, 12),
+                // (30,10): error CS0738: 'C5' does not implement interface member 'I1.M01'. 'C5.M01' cannot implement 'I1.M01' because it does not have the matching return type of 'int'.
+                //     C5 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("C5", "I1.M01", "C5.M01", "int").WithLocation(30, 10),
+                // (36,10): error CS0535: 'C6' does not implement interface member 'I1.M01'
+                //     C6 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C6", "I1.M01").WithLocation(36, 10),
+                // (38,20): error CS0539: 'C6.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static long I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C6.M01").WithLocation(38, 20)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticProperty_02(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract int M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C1 : I1
+{}
+
+" + typeKeyword + @"
+    C2 : I1
+{
+    public static int M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C3 : I1
+{
+    int M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C4 : I1
+{
+    static int I1.M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C5 : I1
+{
+    public long M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C6 : I1
+{
+    long I1.M01 { get; set; }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,10): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                //     C1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01").WithLocation(8, 10),
+                // (12,10): error CS0736: 'C2' does not implement instance interface member 'I1.M01'. 'C2.M01' cannot implement the interface member because it is static.
+                //     C2 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "I1").WithArguments("C2", "I1.M01", "C2.M01").WithLocation(12, 10),
+                // (18,10): error CS0737: 'C3' does not implement interface member 'I1.M01'. 'C3.M01' cannot implement an interface member because it is not public.
+                //     C3 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "I1").WithArguments("C3", "I1.M01", "C3.M01").WithLocation(18, 10),
+                // (24,10): error CS0535: 'C4' does not implement interface member 'I1.M01'
+                //     C4 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C4", "I1.M01").WithLocation(24, 10),
+                // (26,19): error CS0539: 'C4.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static int I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C4.M01").WithLocation(26, 19),
+                // (30,10): error CS0738: 'C5' does not implement interface member 'I1.M01'. 'C5.M01' cannot implement 'I1.M01' because it does not have the matching return type of 'int'.
+                //     C5 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("C5", "I1.M01", "C5.M01", "int").WithLocation(30, 10),
+                // (36,10): error CS0535: 'C6' does not implement interface member 'I1.M01'
+                //     C6 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C6", "I1.M01").WithLocation(36, 10),
+                // (38,13): error CS0539: 'C6.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     long I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C6.M01").WithLocation(38, 13)
+                );
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticProperty_03()
+        {
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+
+interface I2 : I1
+{}
+
+interface I3 : I1
+{
+    public virtual int M01 { get => 0; set{} }
+}
+
+interface I4 : I1
+{
+    static int M01 { get; set; }
+}
+
+interface I5 : I1
+{
+    int I1.M01 { get => 0; set{} }
+}
+
+interface I6 : I1
+{
+    static int I1.M01 { get => 0; set{} }
+}
+
+interface I7 : I1
+{
+    abstract static int M01 { get; set; }
+}
+
+interface I8 : I1
+{
+    abstract static int I1.M01 { get; set; }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (12,24): warning CS0108: 'I3.M01' hides inherited member 'I1.M01'. Use the new keyword if hiding was intended.
+                //     public virtual int M01 { get => 0; set{} }
+                Diagnostic(ErrorCode.WRN_NewRequired, "M01").WithArguments("I3.M01", "I1.M01").WithLocation(12, 24),
+                // (17,16): warning CS0108: 'I4.M01' hides inherited member 'I1.M01'. Use the new keyword if hiding was intended.
+                //     static int M01 { get; set; }
+                Diagnostic(ErrorCode.WRN_NewRequired, "M01").WithArguments("I4.M01", "I1.M01").WithLocation(17, 16),
+                // (22,12): error CS0539: 'I5.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     int I1.M01 { get => 0; set{} }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("I5.M01").WithLocation(22, 12),
+                // (27,19): error CS0106: The modifier 'static' is not valid for this item
+                //     static int I1.M01 { get => 0; set{} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M01").WithArguments("static").WithLocation(27, 19),
+                // (27,19): error CS0539: 'I6.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static int I1.M01 { get => 0; set{} }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("I6.M01").WithLocation(27, 19),
+                // (32,25): warning CS0108: 'I7.M01' hides inherited member 'I1.M01'. Use the new keyword if hiding was intended.
+                //     abstract static int M01 { get; set; }
+                Diagnostic(ErrorCode.WRN_NewRequired, "M01").WithArguments("I7.M01", "I1.M01").WithLocation(32, 25),
+                // (37,28): error CS0106: The modifier 'static' is not valid for this item
+                //     abstract static int I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M01").WithArguments("static").WithLocation(37, 28),
+                // (37,28): error CS0539: 'I8.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     abstract static int I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("I8.M01").WithLocation(37, 28)
+                );
+
+            foreach (var m01 in compilation1.GlobalNamespace.GetTypeMember("I1").GetMembers())
+            {
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I2").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I3").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I4").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I5").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I6").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I7").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I8").FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticProperty_04(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+    abstract static int M02 { get; set; }
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test: I1
+{
+    static int I1.M01 { get; set; }
+    public static int M02 { get; set; }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,19): error CS8703: The modifier 'static' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     static int I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("static", "9.0", "preview").WithLocation(4, 19)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (4,19): error CS8703: The modifier 'static' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     static int I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("static", "9.0", "preview").WithLocation(4, 19),
+                // (10,25): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static int M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(10, 25),
+                // (11,25): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static int M02 { get; set; }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M02").WithArguments("abstract", "9.0", "preview").WithLocation(11, 25)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticProperty_05(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    public static int M01 { get; set; }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (2,12): error CS8929: 'Test1.M01.set' cannot implement interface member 'I1.M01.set' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01.set", "I1.M01.set", "Test1").WithLocation(2, 12),
+                // (2,12): error CS8929: 'Test1.M01.get' cannot implement interface member 'I1.M01.get' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01.get", "I1.M01.get", "Test1").WithLocation(2, 12),
+                // (2,12): error CS8929: 'Test1.M01' cannot implement interface member 'I1.M01' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01", "I1.M01", "Test1").WithLocation(2, 12)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (2,12): error CS8929: 'Test1.M01.set' cannot implement interface member 'I1.M01.set' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01.set", "I1.M01.set", "Test1").WithLocation(2, 12),
+                // (2,12): error CS8929: 'Test1.M01.get' cannot implement interface member 'I1.M01.get' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01.get", "I1.M01.get", "Test1").WithLocation(2, 12),
+                // (2,12): error CS8929: 'Test1.M01' cannot implement interface member 'I1.M01' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01", "I1.M01", "Test1").WithLocation(2, 12),
+                // (9,31): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "get").WithLocation(9, 31),
+                // (9,36): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "set").WithLocation(9, 36)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticProperty_06(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    static int I1.M01 { get; set; }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,19): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static int I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(4, 19)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (4,19): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static int I1.M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(4, 19),
+                // (9,31): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "get").WithLocation(9, 31),
+                // (9,36): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static int M01 { get; set; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "set").WithLocation(9, 36)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticProperty_07(bool structure)
+        {
+            // Basic implicit implementation scenario, MethodImpl is emitted
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C : I1
+{
+    public static int M01 { get => 0; set {} }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<PropertySymbol>().Single();
+                var m01Get = m01.GetMethod;
+                var m01Set = m01.SetMethod;
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (PropertySymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+
+                Assert.Equal("System.Int32 C.M01 { get; set; }", cM01.ToTestDisplayString());
+
+                var cM01Get = cM01.GetMethod;
+                Assert.Same(cM01Get, c.FindImplementationForInterfaceMember(m01Get));
+
+                Assert.True(cM01Get.IsStatic);
+                Assert.False(cM01Get.IsAbstract);
+                Assert.False(cM01Get.IsVirtual);
+                Assert.False(cM01Get.IsMetadataVirtual());
+                Assert.False(cM01Get.IsMetadataFinal);
+                Assert.False(cM01Get.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertyGet, cM01Get.MethodKind);
+                Assert.False(cM01Get.HasRuntimeSpecialName);
+                Assert.True(cM01Get.HasSpecialName);
+
+                Assert.Equal("System.Int32 C.M01.get", cM01Get.ToTestDisplayString());
+
+                var cM01Set = cM01.SetMethod;
+                Assert.Same(cM01Set, c.FindImplementationForInterfaceMember(m01Set));
+
+                Assert.True(cM01Set.IsStatic);
+                Assert.False(cM01Set.IsAbstract);
+                Assert.False(cM01Set.IsVirtual);
+                Assert.False(cM01Set.IsMetadataVirtual());
+                Assert.False(cM01Set.IsMetadataFinal);
+                Assert.False(cM01Set.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertySet, cM01Set.MethodKind);
+                Assert.False(cM01Set.HasRuntimeSpecialName);
+                Assert.True(cM01Set.HasSpecialName);
+
+                Assert.Equal("void C.M01.set", cM01Set.ToTestDisplayString());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                    Assert.Same(m01Get, cM01Get.ExplicitInterfaceImplementations.Single());
+                    Assert.Same(m01Set, cM01Set.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                    Assert.Empty(cM01Get.ExplicitInterfaceImplementations);
+                    Assert.Empty(cM01Set.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticReadonlyProperty_07(bool structure)
+        {
+            // Basic implicit implementation scenario, MethodImpl is emitted
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; }
+}
+
+" + typeKeyword + @"
+    C : I1
+{
+    public static int M01 { get; set; }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<PropertySymbol>().Single();
+                var m01Get = m01.GetMethod;
+                Assert.Null(m01.SetMethod);
+
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (PropertySymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+
+                Assert.Equal("System.Int32 C.M01 { get; set; }", cM01.ToTestDisplayString());
+
+                var cM01Get = cM01.GetMethod;
+                Assert.Same(cM01Get, c.FindImplementationForInterfaceMember(m01Get));
+
+                Assert.True(cM01Get.IsStatic);
+                Assert.False(cM01Get.IsAbstract);
+                Assert.False(cM01Get.IsVirtual);
+                Assert.False(cM01Get.IsMetadataVirtual());
+                Assert.False(cM01Get.IsMetadataFinal);
+                Assert.False(cM01Get.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertyGet, cM01Get.MethodKind);
+
+                Assert.Equal("System.Int32 C.M01.get", cM01Get.ToTestDisplayString());
+
+                var cM01Set = cM01.SetMethod;
+
+                Assert.True(cM01Set.IsStatic);
+                Assert.False(cM01Set.IsAbstract);
+                Assert.False(cM01Set.IsVirtual);
+                Assert.False(cM01Set.IsMetadataVirtual());
+                Assert.False(cM01Set.IsMetadataFinal);
+                Assert.False(cM01Set.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertySet, cM01Set.MethodKind);
+
+                Assert.Equal("void C.M01.set", cM01Set.ToTestDisplayString());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                    Assert.Same(m01Get, cM01Get.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                    Assert.Empty(cM01Get.ExplicitInterfaceImplementations);
+                }
+
+                Assert.Empty(cM01Set.ExplicitInterfaceImplementations);
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticProperty_08(bool structure)
+        {
+            // Basic explicit implementation scenario
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+
+" + typeKeyword + @"
+    C : I1
+{
+    static int I1.M01 { get => 0; set {} }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<PropertySymbol>().Single();
+                var m01Get = m01.GetMethod;
+                var m01Set = m01.SetMethod;
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (PropertySymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+
+                Assert.Equal("System.Int32 C.I1.M01 { get; set; }", cM01.ToTestDisplayString());
+
+                var cM01Get = cM01.GetMethod;
+                Assert.Same(cM01Get, c.FindImplementationForInterfaceMember(m01Get));
+
+                Assert.True(cM01Get.IsStatic);
+                Assert.False(cM01Get.IsAbstract);
+                Assert.False(cM01Get.IsVirtual);
+                Assert.False(cM01Get.IsMetadataVirtual());
+                Assert.False(cM01Get.IsMetadataFinal);
+                Assert.False(cM01Get.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertyGet, cM01Get.MethodKind);
+                Assert.False(cM01Get.HasRuntimeSpecialName);
+                Assert.True(cM01Get.HasSpecialName);
+
+                Assert.Equal("System.Int32 C.I1.M01.get", cM01Get.ToTestDisplayString());
+
+                var cM01Set = cM01.SetMethod;
+                Assert.Same(cM01Set, c.FindImplementationForInterfaceMember(m01Set));
+
+                Assert.True(cM01Set.IsStatic);
+                Assert.False(cM01Set.IsAbstract);
+                Assert.False(cM01Set.IsVirtual);
+                Assert.False(cM01Set.IsMetadataVirtual());
+                Assert.False(cM01Set.IsMetadataFinal);
+                Assert.False(cM01Set.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertySet, cM01Set.MethodKind);
+                Assert.False(cM01Set.HasRuntimeSpecialName);
+                Assert.True(cM01Set.HasSpecialName);
+
+                Assert.Equal("void C.I1.M01.set", cM01Set.ToTestDisplayString());
+
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01Get, cM01Get.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01Set, cM01Set.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticProperty_09()
+        {
+            // Explicit implementation from base is treated as an implementation
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+
+public class C1
+{
+    public static void M01() {}
+}
+
+public class C2 : C1, I1
+{
+    static int I1.M01 { get; set; }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                     parseOptions: parseOptions,
+                                                     targetFramework: TargetFramework.NetCoreApp,
+                                                     references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<PropertySymbol>());
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+                var m01 = c3.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+
+                var cM01 = (PropertySymbol)c3.FindImplementationForInterfaceMember(m01);
+
+                Assert.Equal("System.Int32 C2.I1.M01 { get; set; }", cM01.ToTestDisplayString());
+
+                Assert.Same(cM01.GetMethod, c3.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Same(cM01.SetMethod, c3.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.GetMethod, cM01.GetMethod.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.SetMethod, cM01.SetMethod.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticProperty_10()
+        {
+            // Implicit implementation is considered only for types implementing interface in source.
+            // In metadata, only explicit implementations are considered
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        int32 get_M01 () cil managed 
+    {
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void set_M01 (
+            int32 'value'
+        ) cil managed 
+    {
+    }
+
+    .property int32 M01()
+    {
+        .get int32 I1::get_M01()
+        .set void I1::set_M01(int32)
+    }
+}
+
+.class public auto ansi beforefieldinit C1
+    extends System.Object
+    implements I1
+{
+    .method private hidebysig specialname static
+        int32 I1.get_M01 () cil managed 
+    {
+        .override method int32 I1::get_M01()
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method private hidebysig specialname static
+        void I1.set_M01 (
+            int32 'value'
+        ) cil managed 
+    {
+        .override method void I1::set_M01(int32)
+        IL_0000: ret
+    }
+
+    .property instance int32 I1.M01()
+    {
+        .get int32 C1::I1.get_M01()
+        .set void C1::I1.set_M01(int32)
+    }
+
+    .method public hidebysig specialname static 
+        int32 get_M01 () cil managed 
+    {
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname static 
+        void set_M01 (
+            int32 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .property int32 M01()
+    {
+        .get int32 C1::get_M01()
+        .set void C1::set_M01(int32)
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    }
+}
+
+.class public auto ansi beforefieldinit C2
+    extends C1
+    implements I1
+{
+    .method public hidebysig specialname static 
+        int32 get_M01 () cil managed 
+    {
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname static 
+        void set_M01 (
+            int32 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .property int32 M01()
+    {
+        .get int32 C2::get_M01()
+        .set void C2::set_M01(int32)
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void C1::.ctor()
+        IL_0006: ret
+    }
+}
+";
+            var source1 =
+@"
+public class C3 : C2
+{
+}
+
+public class C4 : C1, I1
+{
+}
+
+public class C5 : C2, I1
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var m01 = c1.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+
+            var c1M01 = (PropertySymbol)c1.FindImplementationForInterfaceMember(m01);
+
+            Assert.Equal("System.Int32 C1.I1.M01 { get; set; }", c1M01.ToTestDisplayString());
+
+            Assert.Same(c1M01.GetMethod, c1.FindImplementationForInterfaceMember(m01.GetMethod));
+            Assert.Same(c1M01.SetMethod, c1.FindImplementationForInterfaceMember(m01.SetMethod));
+            Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+            Assert.Same(m01.GetMethod, c1M01.GetMethod.ExplicitInterfaceImplementations.Single());
+            Assert.Same(m01.SetMethod, c1M01.SetMethod.ExplicitInterfaceImplementations.Single());
+
+            var c2 = compilation1.GlobalNamespace.GetTypeMember("C2");
+            Assert.Same(c1M01, c2.FindImplementationForInterfaceMember(m01));
+            Assert.Same(c1M01.GetMethod, c2.FindImplementationForInterfaceMember(m01.GetMethod));
+            Assert.Same(c1M01.SetMethod, c2.FindImplementationForInterfaceMember(m01.SetMethod));
+
+            var c3 = compilation1.GlobalNamespace.GetTypeMember("C3");
+            Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+            Assert.Same(c1M01.GetMethod, c3.FindImplementationForInterfaceMember(m01.GetMethod));
+            Assert.Same(c1M01.SetMethod, c3.FindImplementationForInterfaceMember(m01.SetMethod));
+
+            var c4 = compilation1.GlobalNamespace.GetTypeMember("C4");
+            Assert.Same(c1M01, c4.FindImplementationForInterfaceMember(m01));
+            Assert.Same(c1M01.GetMethod, c4.FindImplementationForInterfaceMember(m01.GetMethod));
+            Assert.Same(c1M01.SetMethod, c4.FindImplementationForInterfaceMember(m01.SetMethod));
+
+            var c5 = compilation1.GlobalNamespace.GetTypeMember("C5");
+
+            var c2M01 = (PropertySymbol)c5.FindImplementationForInterfaceMember(m01);
+            Assert.Equal("System.Int32 C2.M01 { get; set; }", c2M01.ToTestDisplayString());
+            Assert.Same(c2M01.GetMethod, c5.FindImplementationForInterfaceMember(m01.GetMethod));
+            Assert.Same(c2M01.SetMethod, c5.FindImplementationForInterfaceMember(m01.SetMethod));
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticProperty_11()
+        {
+            // Ignore invalid metadata (non-abstract static virtual method). 
+            scenario1();
+            scenario2();
+            scenario3();
+
+            void scenario1()
+            {
+                var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method private hidebysig specialname static virtual
+        int32 get_M01 () cil managed 
+    {
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method private hidebysig specialname static virtual
+        void set_M01 (
+            int32 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .property int32 M01()
+    {
+        .get int32 I1::get_M01()
+        .set void I1::set_M01(int32)
+    }
+}
+";
+
+                var source1 =
+@"
+public class C1 : I1
+{
+}
+";
+
+                var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation1.VerifyEmitDiagnostics();
+
+                var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+                var i1 = c1.Interfaces().Single();
+                var m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation1.VerifyEmitDiagnostics();
+
+                var source2 =
+@"
+public class C1 : I1
+{
+   static int I1.M01 { get; set; }
+}
+";
+
+                var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation2.VerifyEmitDiagnostics(
+                    // (4,18): error CS0539: 'C1.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                    //    static int I1.M01 { get; set; }
+                    Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C1.M01").WithLocation(4, 18)
+                    );
+
+                c1 = compilation2.GlobalNamespace.GetTypeMember("C1");
+                m01 = c1.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                var source3 =
+@"
+public class C1 : I1
+{
+   public static int M01 { get; set; }
+}
+";
+
+                var compilation3 = CreateCompilationWithIL(source3, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation3, sourceSymbolValidator: validate3, symbolValidator: validate3, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate3(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+                    Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                    Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01));
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.GetMethod));
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.SetMethod));
+                }
+            }
+
+            void scenario2()
+            {
+                var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        int32 get_M01 () cil managed 
+    {
+    }
+
+    .method private hidebysig specialname static virtual
+        void set_M01 (
+            int32 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .property int32 M01()
+    {
+        .get int32 I1::get_M01()
+        .set void I1::set_M01(int32)
+    }
+}
+";
+
+                var source1 =
+@"
+public class C1 : I1
+{
+}
+";
+
+                var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation1.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01").WithLocation(2, 19)
+                    );
+
+                var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+                var i1 = c1.Interfaces().Single();
+                var m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                var source2 =
+@"
+public class C1 : I1
+{
+   static int I1.M01 { get; }
+}
+";
+
+                var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation2, sourceSymbolValidator: validate2, symbolValidator: validate2, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate2(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+                    var m01Get = m01.GetMethod;
+                    var m01Set = m01.SetMethod;
+
+                    Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                    Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var cM01 = (PropertySymbol)c.FindImplementationForInterfaceMember(m01);
+
+                    Assert.True(cM01.IsStatic);
+                    Assert.False(cM01.IsAbstract);
+                    Assert.False(cM01.IsVirtual);
+
+                    Assert.Equal("System.Int32 C1.I1.M01 { get; }", cM01.ToTestDisplayString());
+
+                    var cM01Get = cM01.GetMethod;
+                    Assert.Same(cM01Get, c.FindImplementationForInterfaceMember(m01Get));
+
+                    Assert.True(cM01Get.IsStatic);
+                    Assert.False(cM01Get.IsAbstract);
+                    Assert.False(cM01Get.IsVirtual);
+                    Assert.False(cM01Get.IsMetadataVirtual());
+                    Assert.False(cM01Get.IsMetadataFinal);
+                    Assert.False(cM01Get.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertyGet, cM01Get.MethodKind);
+
+                    Assert.Equal("System.Int32 C1.I1.M01.get", cM01Get.ToTestDisplayString());
+
+                    Assert.Null(cM01.SetMethod);
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01Set));
+
+                    Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                    Assert.Same(m01Get, cM01Get.ExplicitInterfaceImplementations.Single());
+                }
+
+                var source3 =
+@"
+public class C1 : I1
+{
+   public static int M01 { get; set; }
+}
+";
+
+                var compilation3 = CreateCompilationWithIL(source3, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation3, sourceSymbolValidator: validate3, symbolValidator: validate3, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate3(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+                    var m01Get = m01.GetMethod;
+
+                    Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                    Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var cM01 = (PropertySymbol)c.FindImplementationForInterfaceMember(m01);
+
+                    Assert.True(cM01.IsStatic);
+                    Assert.False(cM01.IsAbstract);
+                    Assert.False(cM01.IsVirtual);
+
+                    Assert.Equal("System.Int32 C1.M01 { get; set; }", cM01.ToTestDisplayString());
+
+                    var cM01Get = cM01.GetMethod;
+                    Assert.Same(cM01Get, c.FindImplementationForInterfaceMember(m01Get));
+
+                    Assert.True(cM01Get.IsStatic);
+                    Assert.False(cM01Get.IsAbstract);
+                    Assert.False(cM01Get.IsVirtual);
+                    Assert.False(cM01Get.IsMetadataVirtual());
+                    Assert.False(cM01Get.IsMetadataFinal);
+                    Assert.False(cM01Get.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertyGet, cM01Get.MethodKind);
+
+                    Assert.Equal("System.Int32 C1.M01.get", cM01Get.ToTestDisplayString());
+
+                    var cM01Set = cM01.SetMethod;
+
+                    Assert.True(cM01Set.IsStatic);
+                    Assert.False(cM01Set.IsAbstract);
+                    Assert.False(cM01Set.IsVirtual);
+                    Assert.False(cM01Set.IsMetadataVirtual());
+                    Assert.False(cM01Set.IsMetadataFinal);
+                    Assert.False(cM01Set.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertySet, cM01Set.MethodKind);
+
+                    Assert.Equal("void C1.M01.set", cM01Set.ToTestDisplayString());
+
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                    if (module is PEModuleSymbol)
+                    {
+                        Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                        Assert.Same(m01Get, cM01Get.ExplicitInterfaceImplementations.Single());
+                    }
+                    else
+                    {
+                        Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                        Assert.Empty(cM01Get.ExplicitInterfaceImplementations);
+                    }
+
+                    Assert.Empty(cM01Set.ExplicitInterfaceImplementations);
+                }
+
+                var source4 =
+@"
+public class C1 : I1
+{
+   static int I1.M01 { get; set; }
+}
+";
+
+                var compilation4 = CreateCompilationWithIL(source4, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation4.VerifyDiagnostics(
+                    // (4,29): error CS0550: 'C1.I1.M01.set' adds an accessor not found in interface member 'I1.M01'
+                    //    static int I1.M01 { get; set; }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "set").WithArguments("C1.I1.M01.set", "I1.M01").WithLocation(4, 29)
+                    );
+
+                c1 = compilation4.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+                var c1M01 = c1.GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Same(c1M01.GetMethod, c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.GetMethod, c1M01.GetMethod.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.SetMethod, c1M01.SetMethod.ExplicitInterfaceImplementations.Single());
+
+                var source5 =
+@"
+public class C1 : I1
+{
+   public static int M01 { get; }
+}
+";
+
+                var compilation5 = CreateCompilationWithIL(source5, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation5, sourceSymbolValidator: validate5, symbolValidator: validate5, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate5(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+                    var m01Get = m01.GetMethod;
+
+                    Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                    Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var cM01 = (PropertySymbol)c.FindImplementationForInterfaceMember(m01);
+
+                    Assert.True(cM01.IsStatic);
+                    Assert.False(cM01.IsAbstract);
+                    Assert.False(cM01.IsVirtual);
+
+                    Assert.Equal("System.Int32 C1.M01 { get; }", cM01.ToTestDisplayString());
+
+                    var cM01Get = cM01.GetMethod;
+                    Assert.Same(cM01Get, c.FindImplementationForInterfaceMember(m01Get));
+
+                    Assert.True(cM01Get.IsStatic);
+                    Assert.False(cM01Get.IsAbstract);
+                    Assert.False(cM01Get.IsVirtual);
+                    Assert.False(cM01Get.IsMetadataVirtual());
+                    Assert.False(cM01Get.IsMetadataFinal);
+                    Assert.False(cM01Get.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertyGet, cM01Get.MethodKind);
+
+                    Assert.Equal("System.Int32 C1.M01.get", cM01Get.ToTestDisplayString());
+
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                    if (module is PEModuleSymbol)
+                    {
+                        Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                        Assert.Same(m01Get, cM01Get.ExplicitInterfaceImplementations.Single());
+                    }
+                    else
+                    {
+                        Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                        Assert.Empty(cM01Get.ExplicitInterfaceImplementations);
+                    }
+                }
+
+                var source6 =
+@"
+public class C1 : I1
+{
+   public static int M01 { set{} }
+}
+";
+
+                var compilation6 = CreateCompilationWithIL(source6, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation6.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01.get'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01.get").WithLocation(2, 19)
+                    );
+
+                c1 = compilation6.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                var source7 =
+@"
+public class C1 : I1
+{
+   static int I1.M01 { set{} }
+}
+";
+
+                var compilation7 = CreateCompilationWithIL(source7, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation7.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01.get'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01.get").WithLocation(2, 19),
+                    // (4,18): error CS0551: Explicit interface implementation 'C1.I1.M01' is missing accessor 'I1.M01.get'
+                    //    static int I1.M01 { set{} }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyMissingAccessor, "M01").WithArguments("C1.I1.M01", "I1.M01.get").WithLocation(4, 18),
+                    // (4,24): error CS0550: 'C1.I1.M01.set' adds an accessor not found in interface member 'I1.M01'
+                    //    static int I1.M01 { set{} }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "set").WithArguments("C1.I1.M01.set", "I1.M01").WithLocation(4, 24)
+                    );
+
+                c1 = compilation7.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.SetMethod, c1M01.SetMethod.ExplicitInterfaceImplementations.Single());
+            }
+
+            void scenario3()
+            {
+                var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method private hidebysig specialname static virtual
+        int32 get_M01 () cil managed 
+    {
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void set_M01 (
+            int32 'value'
+        ) cil managed 
+    {
+    }
+
+    .property int32 M01()
+    {
+        .get int32 I1::get_M01()
+        .set void I1::set_M01(int32)
+    }
+}
+";
+
+                var source1 =
+@"
+public class C1 : I1
+{
+}
+";
+
+                var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation1.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01").WithLocation(2, 19)
+                    );
+
+                var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+                var i1 = c1.Interfaces().Single();
+                var m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                var source2 =
+@"
+public class C1 : I1
+{
+   static int I1.M01 { set{} }
+}
+";
+
+                var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation2, sourceSymbolValidator: validate2, symbolValidator: validate2, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate2(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+                    var m01Get = m01.GetMethod;
+                    var m01Set = m01.SetMethod;
+
+                    Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                    Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var cM01 = (PropertySymbol)c.FindImplementationForInterfaceMember(m01);
+
+                    Assert.True(cM01.IsStatic);
+                    Assert.False(cM01.IsAbstract);
+                    Assert.False(cM01.IsVirtual);
+
+                    Assert.Equal("System.Int32 C1.I1.M01 { set; }", cM01.ToTestDisplayString());
+
+                    var cM01Set = cM01.SetMethod;
+                    Assert.Same(cM01Set, c.FindImplementationForInterfaceMember(m01Set));
+
+                    Assert.True(cM01Set.IsStatic);
+                    Assert.False(cM01Set.IsAbstract);
+                    Assert.False(cM01Set.IsVirtual);
+                    Assert.False(cM01Set.IsMetadataVirtual());
+                    Assert.False(cM01Set.IsMetadataFinal);
+                    Assert.False(cM01Set.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertySet, cM01Set.MethodKind);
+
+                    Assert.Equal("void C1.I1.M01.set", cM01Set.ToTestDisplayString());
+
+                    Assert.Null(cM01.GetMethod);
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01Get));
+
+                    Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                    Assert.Same(m01Set, cM01Set.ExplicitInterfaceImplementations.Single());
+                }
+
+                var source3 =
+@"
+public class C1 : I1
+{
+   public static int M01 { get; set; }
+}
+";
+
+                var compilation3 = CreateCompilationWithIL(source3, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation3, sourceSymbolValidator: validate3, symbolValidator: validate3, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate3(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+                    var m01Set = m01.SetMethod;
+
+                    Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                    Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var cM01 = (PropertySymbol)c.FindImplementationForInterfaceMember(m01);
+
+                    Assert.True(cM01.IsStatic);
+                    Assert.False(cM01.IsAbstract);
+                    Assert.False(cM01.IsVirtual);
+
+                    Assert.Equal("System.Int32 C1.M01 { get; set; }", cM01.ToTestDisplayString());
+
+                    var cM01Set = cM01.SetMethod;
+                    Assert.Same(cM01Set, c.FindImplementationForInterfaceMember(m01Set));
+
+                    Assert.True(cM01Set.IsStatic);
+                    Assert.False(cM01Set.IsAbstract);
+                    Assert.False(cM01Set.IsVirtual);
+                    Assert.False(cM01Set.IsMetadataVirtual());
+                    Assert.False(cM01Set.IsMetadataFinal);
+                    Assert.False(cM01Set.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertySet, cM01Set.MethodKind);
+
+                    Assert.Equal("void C1.M01.set", cM01Set.ToTestDisplayString());
+
+                    var cM01Get = cM01.GetMethod;
+
+                    Assert.True(cM01Get.IsStatic);
+                    Assert.False(cM01Get.IsAbstract);
+                    Assert.False(cM01Get.IsVirtual);
+                    Assert.False(cM01Get.IsMetadataVirtual());
+                    Assert.False(cM01Get.IsMetadataFinal);
+                    Assert.False(cM01Get.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertyGet, cM01Get.MethodKind);
+
+                    Assert.Equal("System.Int32 C1.M01.get", cM01Get.ToTestDisplayString());
+
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.GetMethod));
+
+                    if (module is PEModuleSymbol)
+                    {
+                        Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                        Assert.Same(m01Set, cM01Set.ExplicitInterfaceImplementations.Single());
+                    }
+                    else
+                    {
+                        Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                        Assert.Empty(cM01Set.ExplicitInterfaceImplementations);
+                    }
+
+                    Assert.Empty(cM01Get.ExplicitInterfaceImplementations);
+                }
+
+                var source4 =
+@"
+public class C1 : I1
+{
+   static int I1.M01 { get; set; }
+}
+";
+
+                var compilation4 = CreateCompilationWithIL(source4, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation4.VerifyDiagnostics(
+                    // (4,24): error CS0550: 'C1.I1.M01.get' adds an accessor not found in interface member 'I1.M01'
+                    //    static int I1.M01 { get; set; }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "get").WithArguments("C1.I1.M01.get", "I1.M01").WithLocation(4, 24)
+                   );
+
+                c1 = compilation4.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+                var c1M01 = c1.GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Same(c1M01.SetMethod, c1.FindImplementationForInterfaceMember(m01.SetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.GetMethod, c1M01.GetMethod.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.SetMethod, c1M01.SetMethod.ExplicitInterfaceImplementations.Single());
+
+                var source5 =
+@"
+public class C1 : I1
+{
+   public static int M01 { set{} }
+}
+";
+
+                var compilation5 = CreateCompilationWithIL(source5, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation5, sourceSymbolValidator: validate5, symbolValidator: validate5, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate5(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+                    var m01Set = m01.SetMethod;
+
+                    Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count());
+                    Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var cM01 = (PropertySymbol)c.FindImplementationForInterfaceMember(m01);
+
+                    Assert.True(cM01.IsStatic);
+                    Assert.False(cM01.IsAbstract);
+                    Assert.False(cM01.IsVirtual);
+
+                    Assert.Equal("System.Int32 C1.M01 { set; }", cM01.ToTestDisplayString());
+
+                    var cM01Set = cM01.SetMethod;
+                    Assert.Same(cM01Set, c.FindImplementationForInterfaceMember(m01Set));
+
+                    Assert.True(cM01Set.IsStatic);
+                    Assert.False(cM01Set.IsAbstract);
+                    Assert.False(cM01Set.IsVirtual);
+                    Assert.False(cM01Set.IsMetadataVirtual());
+                    Assert.False(cM01Set.IsMetadataFinal);
+                    Assert.False(cM01Set.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertySet, cM01Set.MethodKind);
+
+                    Assert.Equal("void C1.M01.set", cM01Set.ToTestDisplayString());
+
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.GetMethod));
+
+                    if (module is PEModuleSymbol)
+                    {
+                        Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                        Assert.Same(m01Set, cM01Set.ExplicitInterfaceImplementations.Single());
+                    }
+                    else
+                    {
+                        Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                        Assert.Empty(cM01Set.ExplicitInterfaceImplementations);
+                    }
+                }
+
+                var source6 =
+@"
+public class C1 : I1
+{
+   public static int M01 { get; }
+}
+";
+
+                var compilation6 = CreateCompilationWithIL(source6, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation6.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01.set'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01.set").WithLocation(2, 19)
+                    );
+
+                c1 = compilation6.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                var source7 =
+@"
+public class C1 : I1
+{
+   static int I1.M01 { get; }
+}
+";
+
+                var compilation7 = CreateCompilationWithIL(source7, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation7.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01.set'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01.set").WithLocation(2, 19),
+                    // (4,18): error CS0551: Explicit interface implementation 'C1.I1.M01' is missing accessor 'I1.M01.set'
+                    //    static int I1.M01 { get; }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyMissingAccessor, "M01").WithArguments("C1.I1.M01", "I1.M01.set").WithLocation(4, 18),
+                    // (4,24): error CS0550: 'C1.I1.M01.get' adds an accessor not found in interface member 'I1.M01'
+                    //    static int I1.M01 { get; }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "get").WithArguments("C1.I1.M01.get", "I1.M01").WithLocation(4, 24)
+                    );
+
+                c1 = compilation7.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.GetMethod, c1M01.GetMethod.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticProperty_12()
+        {
+            // Ignore invalid metadata (default interface implementation for a static method)
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        int32 get_M01 () cil managed 
+    {
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void set_M01 (
+            int32 'value'
+        ) cil managed 
+    {
+    }
+
+    .property int32 M01()
+    {
+        .get int32 I1::get_M01()
+        .set void I1::set_M01(int32)
+    }
+}
+
+.class interface public auto ansi abstract I2
+    implements I1
+{
+    .method private hidebysig specialname static
+        int32 I1.get_M01 () cil managed 
+    {
+        .override method int32 I1::get_M01()
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method private hidebysig specialname static
+        void I1.set_M01 (
+            int32 'value'
+        ) cil managed 
+    {
+        .override method void I1::set_M01(int32)
+        IL_0000: ret
+    }
+
+    .property instance int32 I1.M01()
+    {
+        .get int32 I2::I1.get_M01()
+        .set void I2::I1.set_M01(int32)
+    }
+}
+";
+
+            var source1 =
+@"
+public class C1 : I2
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics(
+                // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                // public class C1 : I2
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2").WithArguments("C1", "I1.M01").WithLocation(2, 19)
+                );
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i2 = c1.Interfaces().Single();
+            var i1 = i2.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<PropertySymbol>().Single();
+
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01));
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01.GetMethod));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01.GetMethod));
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01.SetMethod));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01.SetMethod));
+
+            var i2M01 = i2.GetMembers().OfType<PropertySymbol>().Single();
+            Assert.Same(m01, i2M01.ExplicitInterfaceImplementations.Single());
+            Assert.Same(m01.GetMethod, i2M01.GetMethod.ExplicitInterfaceImplementations.Single());
+            Assert.Same(m01.SetMethod, i2M01.SetMethod.ExplicitInterfaceImplementations.Single());
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticProperty_13()
+        {
+            // A forwarding method is added for an implicit implementation declared in base class. 
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+
+class C1
+{
+    public static int M01 { get; set; }
+}
+
+class C2 : C1, I1
+{
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<PropertySymbol>().Single();
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+
+                var c2M01 = (PropertySymbol)c2.FindImplementationForInterfaceMember(m01);
+                var c2M01Get = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01.GetMethod);
+                var c2M01Set = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01.SetMethod);
+
+                Assert.True(c2M01Get.IsStatic);
+                Assert.False(c2M01Get.IsAbstract);
+                Assert.False(c2M01Get.IsVirtual);
+                Assert.False(c2M01Get.IsMetadataVirtual());
+                Assert.False(c2M01Get.IsMetadataFinal);
+                Assert.False(c2M01Get.IsMetadataNewSlot());
+
+                Assert.True(c2M01Set.IsStatic);
+                Assert.False(c2M01Set.IsAbstract);
+                Assert.False(c2M01Set.IsVirtual);
+                Assert.False(c2M01Set.IsMetadataVirtual());
+                Assert.False(c2M01Set.IsMetadataFinal);
+                Assert.False(c2M01Set.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01Get.MethodKind);
+                    Assert.False(c2M01Get.HasRuntimeSpecialName);
+                    Assert.False(c2M01Get.HasSpecialName);
+                    Assert.Equal("System.Int32 C2.I1.get_M01()", c2M01Get.ToTestDisplayString());
+                    Assert.Same(m01.GetMethod, c2M01Get.ExplicitInterfaceImplementations.Single());
+
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01Set.MethodKind);
+                    Assert.False(c2M01Set.HasRuntimeSpecialName);
+                    Assert.False(c2M01Set.HasSpecialName);
+                    Assert.Equal("void C2.I1.set_M01(System.Int32 value)", c2M01Set.ToTestDisplayString());
+                    Assert.Same(m01.SetMethod, c2M01Set.ExplicitInterfaceImplementations.Single());
+
+                    // Forwarding methods for accessors aren't tied to a property
+                    Assert.Null(c2M01);
+
+                    var c1M01 = module.GlobalNamespace.GetMember<PropertySymbol>("C1.M01");
+                    var c1M01Get = c1M01.GetMethod;
+                    var c1M01Set = c1M01.SetMethod;
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+
+                    Assert.True(c1M01Get.IsStatic);
+                    Assert.False(c1M01Get.IsAbstract);
+                    Assert.False(c1M01Get.IsVirtual);
+                    Assert.False(c1M01Get.IsMetadataVirtual());
+                    Assert.False(c1M01Get.IsMetadataFinal);
+                    Assert.False(c1M01Get.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertyGet, c1M01Get.MethodKind);
+                    Assert.False(c1M01Get.HasRuntimeSpecialName);
+                    Assert.True(c1M01Get.HasSpecialName);
+                    Assert.Empty(c1M01Get.ExplicitInterfaceImplementations);
+
+                    Assert.True(c1M01Set.IsStatic);
+                    Assert.False(c1M01Set.IsAbstract);
+                    Assert.False(c1M01Set.IsVirtual);
+                    Assert.False(c1M01Set.IsMetadataVirtual());
+                    Assert.False(c1M01Set.IsMetadataFinal);
+                    Assert.False(c1M01Set.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.PropertySet, c1M01Set.MethodKind);
+                    Assert.False(c1M01Set.HasRuntimeSpecialName);
+                    Assert.True(c1M01Set.HasSpecialName);
+                    Assert.Empty(c1M01Set.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.True(c2M01.IsStatic);
+                    Assert.False(c2M01.IsAbstract);
+                    Assert.False(c2M01.IsVirtual);
+
+                    Assert.Equal("System.Int32 C1.M01 { get; set; }", c2M01.ToTestDisplayString());
+                    Assert.Empty(c2M01.ExplicitInterfaceImplementations);
+
+                    Assert.Equal(MethodKind.PropertyGet, c2M01Get.MethodKind);
+                    Assert.False(c2M01Get.HasRuntimeSpecialName);
+                    Assert.True(c2M01Get.HasSpecialName);
+                    Assert.Same(c2M01.GetMethod, c2M01Get);
+                    Assert.Empty(c2M01Get.ExplicitInterfaceImplementations);
+
+                    Assert.Equal(MethodKind.PropertySet, c2M01Set.MethodKind);
+                    Assert.False(c2M01Set.HasRuntimeSpecialName);
+                    Assert.True(c2M01Set.HasSpecialName);
+                    Assert.Same(c2M01.SetMethod, c2M01Set);
+                    Assert.Empty(c2M01Set.ExplicitInterfaceImplementations);
+                }
+            }
+
+            verifier.VerifyIL("C2.I1.get_M01",
+@"
+{
+  // Code size        6 (0x6)
+  .maxstack  1
+  IL_0000:  call       ""int C1.M01.get""
+  IL_0005:  ret
+}
+");
+
+            verifier.VerifyIL("C2.I1.set_M01",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C1.M01.set""
+  IL_0006:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticProperty_14()
+        {
+            // A forwarding method is added for an implicit implementation with modopt mismatch. 
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        int32 get_M01 () cil managed 
+    {
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void modopt(I1) set_M01 (
+            int32 modopt(I1) 'value'
+        ) cil managed 
+    {
+    }
+
+    .property int32 M01()
+    {
+        .get int32 I1::get_M01()
+        .set void modopt(I1) I1::set_M01(int32 modopt(I1))
+    }
+}
+
+.class interface public auto ansi abstract I2
+{
+    .method public hidebysig specialname abstract virtual static 
+        int32 modopt(I2) get_M01 () cil managed 
+    {
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void set_M01 (
+            int32 modopt(I2) 'value'
+        ) cil managed 
+    {
+    }
+
+    .property int32 modopt(I2) M01()
+    {
+        .get int32 modopt(I2) I2::get_M01()
+        .set void I2::set_M01(int32 modopt(I2))
+    }
+}
+";
+
+            var source1 =
+@"
+class C1 : I1
+{
+    public static int M01 { get; set; }
+}
+
+class C2 : I1
+{
+    static int I1.M01 { get; set; }
+}
+
+class C3 : I2
+{
+    static int I2.M01 { get; set; }
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c1 = module.GlobalNamespace.GetTypeMember("C1");
+                var m01 = c1.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+
+                var c1M01 = (PropertySymbol)c1.FindImplementationForInterfaceMember(m01);
+                var c1M01Get = c1M01.GetMethod;
+                var c1M01Set = c1M01.SetMethod;
+
+                Assert.Equal("System.Int32 C1.M01 { get; set; }", c1M01.ToTestDisplayString());
+                Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+
+                Assert.Equal(MethodKind.PropertyGet, c1M01Get.MethodKind);
+                Assert.Equal("System.Int32 C1.M01.get", c1M01Get.ToTestDisplayString());
+                Assert.True(c1M01Get.IsStatic);
+                Assert.False(c1M01Get.IsAbstract);
+                Assert.False(c1M01Get.IsVirtual);
+                Assert.False(c1M01Get.IsMetadataVirtual());
+                Assert.False(c1M01Get.IsMetadataFinal);
+                Assert.False(c1M01Get.IsMetadataNewSlot());
+                Assert.Same(c1M01Get, c1.FindImplementationForInterfaceMember(m01.GetMethod));
+
+                Assert.Equal(MethodKind.PropertySet, c1M01Set.MethodKind);
+                Assert.Equal("void C1.M01.set", c1M01Set.ToTestDisplayString());
+                Assert.Empty(c1M01Set.ExplicitInterfaceImplementations);
+                Assert.True(c1M01Set.IsStatic);
+                Assert.False(c1M01Set.IsAbstract);
+                Assert.False(c1M01Set.IsVirtual);
+                Assert.False(c1M01Set.IsMetadataVirtual());
+                Assert.False(c1M01Set.IsMetadataFinal);
+                Assert.False(c1M01Set.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Same(m01.GetMethod, c1M01Get.ExplicitInterfaceImplementations.Single());
+
+                    c1M01Set = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01.SetMethod);
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01Set.MethodKind);
+                    Assert.Equal("void modopt(I1) C1.I1.set_M01(System.Int32 modopt(I1) value)", c1M01Set.ToTestDisplayString());
+                    Assert.Same(m01.SetMethod, c1M01Set.ExplicitInterfaceImplementations.Single());
+
+                    Assert.True(c1M01Set.IsStatic);
+                    Assert.False(c1M01Set.IsAbstract);
+                    Assert.False(c1M01Set.IsVirtual);
+                    Assert.False(c1M01Set.IsMetadataVirtual());
+                    Assert.False(c1M01Set.IsMetadataFinal);
+                    Assert.False(c1M01Set.IsMetadataNewSlot());
+                }
+                else
+                {
+                    Assert.Empty(c1M01Get.ExplicitInterfaceImplementations);
+                    Assert.Same(c1M01Set, c1.FindImplementationForInterfaceMember(m01.SetMethod));
+                }
+
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+
+                var c2M01 = (PropertySymbol)c2.FindImplementationForInterfaceMember(m01);
+                var c2M01Get = c2M01.GetMethod;
+                var c2M01Set = c2M01.SetMethod;
+
+                Assert.Equal("System.Int32 C2.I1.M01 { get; set; }", c2M01.ToTestDisplayString());
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.Same(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                Assert.True(c2M01Get.IsStatic);
+                Assert.False(c2M01Get.IsAbstract);
+                Assert.False(c2M01Get.IsVirtual);
+                Assert.False(c2M01Get.IsMetadataVirtual());
+                Assert.False(c2M01Get.IsMetadataFinal);
+                Assert.False(c2M01Get.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertyGet, c2M01Get.MethodKind);
+                Assert.Equal("System.Int32 C2.I1.M01.get", c2M01Get.ToTestDisplayString());
+                Assert.Same(m01.GetMethod, c2M01Get.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c2M01Get, c2.FindImplementationForInterfaceMember(m01.GetMethod));
+
+                Assert.True(c2M01Set.IsStatic);
+                Assert.False(c2M01Set.IsAbstract);
+                Assert.False(c2M01Set.IsVirtual);
+                Assert.False(c2M01Set.IsMetadataVirtual());
+                Assert.False(c2M01Set.IsMetadataFinal);
+                Assert.False(c2M01Set.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertySet, c2M01Set.MethodKind);
+                Assert.Equal("void modopt(I1) C2.I1.M01.set", c2M01Set.ToTestDisplayString());
+                Assert.Equal("System.Int32 modopt(I1) value", c2M01Set.Parameters.Single().ToTestDisplayString());
+                Assert.Same(m01.SetMethod, c2M01Set.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c2M01Set, c2.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                Assert.Same(c2M01, c2.GetMembers().OfType<PropertySymbol>().Single());
+                Assert.Equal(2, c2.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                m01 = c3.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+
+                var c3M01 = (PropertySymbol)c3.FindImplementationForInterfaceMember(m01);
+                var c3M01Get = c3M01.GetMethod;
+                var c3M01Set = c3M01.SetMethod;
+
+                Assert.Equal("System.Int32 modopt(I2) C3.I2.M01 { get; set; }", c3M01.ToTestDisplayString());
+
+                Assert.True(c3M01.IsStatic);
+                Assert.False(c3M01.IsAbstract);
+                Assert.False(c3M01.IsVirtual);
+                Assert.Same(m01, c3M01.ExplicitInterfaceImplementations.Single());
+
+                Assert.True(c3M01Get.IsStatic);
+                Assert.False(c3M01Get.IsAbstract);
+                Assert.False(c3M01Get.IsVirtual);
+                Assert.False(c3M01Get.IsMetadataVirtual());
+                Assert.False(c3M01Get.IsMetadataFinal);
+                Assert.False(c3M01Get.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertyGet, c3M01Get.MethodKind);
+                Assert.Equal("System.Int32 modopt(I2) C3.I2.M01.get", c3M01Get.ToTestDisplayString());
+                Assert.Same(m01.GetMethod, c3M01Get.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c3M01Get, c3.FindImplementationForInterfaceMember(m01.GetMethod));
+
+
+                Assert.True(c3M01Set.IsStatic);
+                Assert.False(c3M01Set.IsAbstract);
+                Assert.False(c3M01Set.IsVirtual);
+                Assert.False(c3M01Set.IsMetadataVirtual());
+                Assert.False(c3M01Set.IsMetadataFinal);
+                Assert.False(c3M01Set.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.PropertySet, c3M01Set.MethodKind);
+                Assert.Equal("void C3.I2.M01.set", c3M01Set.ToTestDisplayString());
+                Assert.Equal("System.Int32 modopt(I2) value", c3M01Set.Parameters.Single().ToTestDisplayString());
+                Assert.Same(m01.SetMethod, c3M01Set.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c3M01Set, c3.FindImplementationForInterfaceMember(m01.SetMethod));
+
+                Assert.Same(c3M01, c3.GetMembers().OfType<PropertySymbol>().Single());
+                Assert.Equal(2, c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+            }
+
+            verifier.VerifyIL("C1.I1.set_M01",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C1.M01.set""
+  IL_0006:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ImplementAbstractStatiProperty_15()
+        {
+            // A forwarding method isn't created if base class implements interface exactly the same way. 
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+    abstract static int M02 { get; set; }
+}
+
+public class C1
+{
+    public static int M01 { get; set; }
+}
+
+public class C2 : C1, I1
+{
+    static int I1.M02 { get; set; }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.RegularPreview, TestOptions.Regular9 })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<PropertySymbol>());
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+
+                var m01 = c3.Interfaces().Single().GetMembers("M01").OfType<PropertySymbol>().Single();
+
+                var c1M01 = c3.BaseType().BaseType().GetMember<PropertySymbol>("M01");
+                Assert.Equal("System.Int32 C1.M01 { get; set; }", c1M01.ToTestDisplayString());
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+
+                Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+
+                var c1M01Get = c1M01.GetMethod;
+                Assert.True(c1M01Get.IsStatic);
+                Assert.False(c1M01Get.IsAbstract);
+                Assert.False(c1M01Get.IsVirtual);
+                Assert.False(c1M01Get.IsMetadataVirtual());
+                Assert.False(c1M01Get.IsMetadataFinal);
+                Assert.False(c1M01Get.IsMetadataNewSlot());
+
+                Assert.Empty(c1M01Get.ExplicitInterfaceImplementations);
+
+                var c1M01Set = c1M01.SetMethod;
+                Assert.True(c1M01Set.IsStatic);
+                Assert.False(c1M01Set.IsAbstract);
+                Assert.False(c1M01Set.IsVirtual);
+                Assert.False(c1M01Set.IsMetadataVirtual());
+                Assert.False(c1M01Set.IsMetadataFinal);
+                Assert.False(c1M01Set.IsMetadataNewSlot());
+
+                Assert.Empty(c1M01Set.ExplicitInterfaceImplementations);
+
+                if (c1M01.ContainingModule is PEModuleSymbol)
+                {
+                    var c2M01Get = c3.FindImplementationForInterfaceMember(m01.GetMethod);
+                    Assert.Equal("System.Int32 C2.I1.get_M01()", c2M01Get.ToTestDisplayString());
+
+                    var c2M01Set = c3.FindImplementationForInterfaceMember(m01.SetMethod);
+                    Assert.Equal("void C2.I1.set_M01(System.Int32 value)", c2M01Set.ToTestDisplayString());
+
+                    // Forwarding methods for accessors aren't tied to a property
+                    Assert.Null(c3.FindImplementationForInterfaceMember(m01));
+                }
+                else
+                {
+                    Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+                    Assert.Same(c1M01.GetMethod, c3.FindImplementationForInterfaceMember(m01.GetMethod));
+                    Assert.Same(c1M01.SetMethod, c3.FindImplementationForInterfaceMember(m01.SetMethod));
+                }
+
+                var m02 = c3.Interfaces().Single().GetMembers("M02").OfType<PropertySymbol>().Single();
+
+                var c2M02 = c3.BaseType().GetMember<PropertySymbol>("I1.M02");
+                Assert.Equal("System.Int32 C2.I1.M02 { get; set; }", c2M02.ToTestDisplayString());
+                Assert.Same(c2M02, c3.FindImplementationForInterfaceMember(m02));
+                Assert.Same(c2M02.GetMethod, c3.FindImplementationForInterfaceMember(m02.GetMethod));
+                Assert.Same(c2M02.SetMethod, c3.FindImplementationForInterfaceMember(m02.SetMethod));
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticProperty_16()
+        {
+            // A new implicit implementation is properly considered.
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+
+public class C1 : I1
+{
+    public static int M01 { get; set; }
+}
+
+public class C2 : C1
+{
+    new public static int M01 { get; set; }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    var verifier = CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+                    verifier.VerifyIL("C3.I1.get_M01",
+@"
+{
+  // Code size        6 (0x6)
+  .maxstack  1
+  IL_0000:  call       ""int C2.M01.get""
+  IL_0005:  ret
+}
+");
+
+                    verifier.VerifyIL("C3.I1.set_M01",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C2.M01.set""
+  IL_0006:  ret
+}
+");
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                var m01 = c3.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+
+                var c2M01 = c3.BaseType().GetMember<PropertySymbol>("M01");
+                var c2M01Get = c2M01.GetMethod;
+                var c2M01Set = c2M01.SetMethod;
+                Assert.Equal("System.Int32 C2.M01 { get; set; }", c2M01.ToTestDisplayString());
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.Empty(c2M01.ExplicitInterfaceImplementations);
+
+                Assert.True(c2M01Get.IsStatic);
+                Assert.False(c2M01Get.IsAbstract);
+                Assert.False(c2M01Get.IsVirtual);
+                Assert.False(c2M01Get.IsMetadataVirtual());
+                Assert.False(c2M01Get.IsMetadataFinal);
+                Assert.False(c2M01Get.IsMetadataNewSlot());
+                Assert.Empty(c2M01Get.ExplicitInterfaceImplementations);
+
+                Assert.True(c2M01Set.IsStatic);
+                Assert.False(c2M01Set.IsAbstract);
+                Assert.False(c2M01Set.IsVirtual);
+                Assert.False(c2M01Set.IsMetadataVirtual());
+                Assert.False(c2M01Set.IsMetadataFinal);
+                Assert.False(c2M01Set.IsMetadataNewSlot());
+                Assert.Empty(c2M01Set.ExplicitInterfaceImplementations);
+
+                if (module is PEModuleSymbol)
+                {
+                    var c3M01 = (PropertySymbol)c3.FindImplementationForInterfaceMember(m01);
+                    // Forwarding methods for accessors aren't tied to a property
+                    Assert.Null(c3M01);
+
+                    var c3M01Get = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01.GetMethod);
+                    Assert.Equal("System.Int32 C3.I1.get_M01()", c3M01Get.ToTestDisplayString());
+                    Assert.Same(m01.GetMethod, c3M01Get.ExplicitInterfaceImplementations.Single());
+
+                    var c3M01Set = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01.SetMethod);
+                    Assert.Equal("void C3.I1.set_M01(System.Int32 value)", c3M01Set.ToTestDisplayString());
+                    Assert.Same(m01.SetMethod, c3M01Set.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Same(c2M01, c3.FindImplementationForInterfaceMember(m01));
+                    Assert.Same(c2M01Get, c3.FindImplementationForInterfaceMember(m01.GetMethod));
+                    Assert.Same(c2M01Set, c3.FindImplementationForInterfaceMember(m01.SetMethod));
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticProperty_19(bool genericFirst)
+        {
+            // An "ambiguity" in implicit/explicit implementation declared in generic base class.
+
+            var generic =
+@"
+    public static T M01 { get; set; }
+";
+            var nonGeneric =
+@"
+    static int I1.M01 { get; set; }
+";
+            var source1 =
+@"
+public interface I1
+{
+    abstract static int M01 { get; set; }
+}
+
+public class C1<T> : I1
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count());
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C1<int>, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (PropertySymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("System.Int32 C1<T>.I1.M01 { get; set; }", c1M01.OriginalDefinition.ToTestDisplayString());
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c1M01, c2.BaseType().FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticProperty_20(bool genericFirst)
+        {
+            // Same as ImplementAbstractStaticProperty_19 only interface is generic too.
+
+            var generic =
+@"
+    static T I1<T>.M01 { get; set; }
+";
+            var nonGeneric =
+@"
+    public static int M01 { get; set; }
+";
+            var source1 =
+@"
+public interface I1<T>
+{
+    abstract static T M01 { get; set; }
+}
+
+public class C1<T> : I1<T>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count());
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C1<int>, I1<int>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<PropertySymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (PropertySymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("T C1<T>.I1<T>.M01 { get; set; }", c1M01.OriginalDefinition.ToTestDisplayString());
+                Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c1M01, c2.BaseType().FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticEvent_01(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"#pragma warning disable CS0067 // WRN_UnreferencedEvent
+public interface I1
+{
+    abstract static event System.Action M01;
+}
+
+" + typeKeyword + @"
+    C1 : I1
+{}
+
+" + typeKeyword + @"
+    C2 : I1
+{
+    public event System.Action M01;
+}
+
+" + typeKeyword + @"
+    C3 : I1
+{
+    static event System.Action M01;
+}
+
+" + typeKeyword + @"
+    C4 : I1
+{
+    event System.Action I1.M01 { add{} remove{}}
+}
+
+" + typeKeyword + @"
+    C5 : I1
+{
+    public static event System.Action<int> M01;
+}
+
+" + typeKeyword + @"
+    C6 : I1
+{
+    static event System.Action<int> I1.M01 { add{} remove{}}
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,10): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                //     C1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01").WithLocation(8, 10),
+                // (12,10): error CS8928: 'C2' does not implement static interface member 'I1.M01'. 'C2.M01' cannot implement the interface member because it is not static.
+                //     C2 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotStatic, "I1").WithArguments("C2", "I1.M01", "C2.M01").WithLocation(12, 10),
+                // (18,10): error CS0737: 'C3' does not implement interface member 'I1.M01'. 'C3.M01' cannot implement an interface member because it is not public.
+                //     C3 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "I1").WithArguments("C3", "I1.M01", "C3.M01").WithLocation(18, 10),
+                // (24,10): error CS0535: 'C4' does not implement interface member 'I1.M01'
+                //     C4 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C4", "I1.M01").WithLocation(24, 10),
+                // (26,28): error CS0539: 'C4.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     event System.Action I1.M01 { add{} remove{}}
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C4.M01").WithLocation(26, 28),
+                // (30,10): error CS0738: 'C5' does not implement interface member 'I1.M01'. 'C5.M01' cannot implement 'I1.M01' because it does not have the matching return type of 'Action'.
+                //     C5 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("C5", "I1.M01", "C5.M01", "System.Action").WithLocation(30, 10),
+                // (36,10): error CS0535: 'C6' does not implement interface member 'I1.M01'
+                //     C6 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C6", "I1.M01").WithLocation(36, 10),
+                // (38,40): error CS0539: 'C6.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static event System.Action<int> I1.M01 { add{} remove{}}
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C6.M01").WithLocation(38, 40)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticEvent_02(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"#pragma warning disable CS0067 // WRN_UnreferencedEvent
+public interface I1
+{
+    abstract event System.Action M01;
+}
+
+" + typeKeyword + @"
+    C1 : I1
+{}
+
+" + typeKeyword + @"
+    C2 : I1
+{
+    public static event System.Action M01;
+}
+
+" + typeKeyword + @"
+    C3 : I1
+{
+    event System.Action M01;
+}
+
+" + typeKeyword + @"
+    C4 : I1
+{
+    static event System.Action I1.M01 { add{} remove{} }
+}
+
+" + typeKeyword + @"
+    C5 : I1
+{
+    public event System.Action<int> M01;
+}
+
+" + typeKeyword + @"
+    C6 : I1
+{
+    event System.Action<int> I1.M01 { add{} remove{} }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,10): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                //     C1 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01").WithLocation(8, 10),
+                // (12,10): error CS0736: 'C2' does not implement instance interface member 'I1.M01'. 'C2.M01' cannot implement the interface member because it is static.
+                //     C2 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberStatic, "I1").WithArguments("C2", "I1.M01", "C2.M01").WithLocation(12, 10),
+                // (18,10): error CS0737: 'C3' does not implement interface member 'I1.M01'. 'C3.M01' cannot implement an interface member because it is not public.
+                //     C3 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "I1").WithArguments("C3", "I1.M01", "C3.M01").WithLocation(18, 10),
+                // (24,10): error CS0535: 'C4' does not implement interface member 'I1.M01'
+                //     C4 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C4", "I1.M01").WithLocation(24, 10),
+                // (26,35): error CS0539: 'C4.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static event System.Action I1.M01 { add{} remove{} }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C4.M01").WithLocation(26, 35),
+                // (30,10): error CS0738: 'C5' does not implement interface member 'I1.M01'. 'C5.M01' cannot implement 'I1.M01' because it does not have the matching return type of 'Action'.
+                //     C5 : I1
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1").WithArguments("C5", "I1.M01", "C5.M01", "System.Action").WithLocation(30, 10),
+                // (36,10): error CS0535: 'C6' does not implement interface member 'I1.M01'
+                //     C6 : I1
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C6", "I1.M01").WithLocation(36, 10),
+                // (38,33): error CS0539: 'C6.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     event System.Action<int> I1.M01 { add{} remove{} }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C6.M01").WithLocation(38, 33)
+                );
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticEvent_03()
+        {
+            var source1 =
+@"#pragma warning disable CS0067 // WRN_UnreferencedEvent
+public interface I1
+{
+    abstract static event System.Action M01;
+}
+
+interface I2 : I1
+{}
+
+interface I3 : I1
+{
+    public virtual event System.Action M01 { add{} remove{} }
+}
+
+interface I4 : I1
+{
+    static event System.Action M01;
+}
+
+interface I5 : I1
+{
+    event System.Action I1.M01 { add{} remove{} }
+}
+
+interface I6 : I1
+{
+    static event System.Action I1.M01 { add{} remove{} }
+}
+
+interface I7 : I1
+{
+    abstract static event System.Action M01;
+}
+
+interface I8 : I1
+{
+    abstract static event System.Action I1.M01;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (12,40): warning CS0108: 'I3.M01' hides inherited member 'I1.M01'. Use the new keyword if hiding was intended.
+                //     public virtual event System.Action M01 { add{} remove{} }
+                Diagnostic(ErrorCode.WRN_NewRequired, "M01").WithArguments("I3.M01", "I1.M01").WithLocation(12, 40),
+                // (17,32): warning CS0108: 'I4.M01' hides inherited member 'I1.M01'. Use the new keyword if hiding was intended.
+                //     static event System.Action M01;
+                Diagnostic(ErrorCode.WRN_NewRequired, "M01").WithArguments("I4.M01", "I1.M01").WithLocation(17, 32),
+                // (22,28): error CS0539: 'I5.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     event System.Action I1.M01 { add{} remove{} }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("I5.M01").WithLocation(22, 28),
+                // (27,35): error CS0106: The modifier 'static' is not valid for this item
+                //     static event System.Action I1.M01 { add{} remove{} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M01").WithArguments("static").WithLocation(27, 35),
+                // (27,35): error CS0539: 'I6.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static event System.Action I1.M01 { add{} remove{} }
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("I6.M01").WithLocation(27, 35),
+                // (32,41): warning CS0108: 'I7.M01' hides inherited member 'I1.M01'. Use the new keyword if hiding was intended.
+                //     abstract static event System.Action M01;
+                Diagnostic(ErrorCode.WRN_NewRequired, "M01").WithArguments("I7.M01", "I1.M01").WithLocation(32, 41),
+                // (37,44): error CS0106: The modifier 'static' is not valid for this item
+                //     abstract static event System.Action I1.M01 { add{} remove{} }
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "M01").WithArguments("static").WithLocation(37, 44),
+                // (37,44): error CS0539: 'I8.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     abstract static event System.Action I1.M01;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("I8.M01").WithLocation(37, 44)
+                );
+
+            foreach (var m01 in compilation1.GlobalNamespace.GetTypeMember("I1").GetMembers())
+            {
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I2").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I3").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I4").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I5").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I6").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I7").FindImplementationForInterfaceMember(m01));
+                Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I8").FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticEvent_04(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action M01;
+    abstract static event System.Action M02;
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test: I1
+{
+    static event System.Action I1.M01 { add{} remove => throw null; }
+    public static event System.Action M02;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,35): error CS8703: The modifier 'static' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     static event System.Action I1.M01 { add{} remove => throw null; }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("static", "9.0", "preview").WithLocation(4, 35),
+                // (5,39): warning CS0067: The event 'Test.M02' is never used
+                //     public static event System.Action M02;
+                Diagnostic(ErrorCode.WRN_UnreferencedEvent, "M02").WithArguments("Test.M02").WithLocation(5, 39)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (4,35): error CS8703: The modifier 'static' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     static event System.Action I1.M01 { add{} remove => throw null; }
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("static", "9.0", "preview").WithLocation(4, 35),
+                // (5,39): warning CS0067: The event 'Test.M02' is never used
+                //     public static event System.Action M02;
+                Diagnostic(ErrorCode.WRN_UnreferencedEvent, "M02").WithArguments("Test.M02").WithLocation(5, 39),
+                // (10,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static event System.Action M01;
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M01").WithArguments("abstract", "9.0", "preview").WithLocation(10, 41),
+                // (11,41): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static event System.Action M02;
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "M02").WithArguments("abstract", "9.0", "preview").WithLocation(11, 41)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticEvent_05(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action M01;
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    public static event System.Action M01 { add{} remove{} }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (2,12): error CS8929: 'Test1.M01.remove' cannot implement interface member 'I1.M01.remove' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01.remove", "I1.M01.remove", "Test1").WithLocation(2, 12),
+                // (2,12): error CS8929: 'Test1.M01.add' cannot implement interface member 'I1.M01.add' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01.add", "I1.M01.add", "Test1").WithLocation(2, 12),
+                // (2,12): error CS8929: 'Test1.M01' cannot implement interface member 'I1.M01' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01", "I1.M01", "Test1").WithLocation(2, 12)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (2,12): error CS8929: 'Test1.M01.remove' cannot implement interface member 'I1.M01.remove' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01.remove", "I1.M01.remove", "Test1").WithLocation(2, 12),
+                // (2,12): error CS8929: 'Test1.M01.add' cannot implement interface member 'I1.M01.add' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01.add", "I1.M01.add", "Test1").WithLocation(2, 12),
+                // (2,12): error CS8929: 'Test1.M01' cannot implement interface member 'I1.M01' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1").WithArguments("Test1.M01", "I1.M01", "Test1").WithLocation(2, 12),
+                // (9,41): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static event System.Action M01;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(9, 41)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticEvent_06(bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action M01;
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1
+{
+    static event System.Action I1.M01 { add => throw null; remove => throw null; }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static event System.Action I1.M01 { add => throw null; remove => throw null; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(4, 35)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (4,35): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static event System.Action I1.M01 { add => throw null; remove => throw null; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(4, 35),
+                // (9,41): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static event System.Action M01;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "M01").WithLocation(9, 41)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticEvent_07(bool structure)
+        {
+            // Basic implicit implementation scenario, MethodImpl is emitted
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action M01;
+}
+
+" + typeKeyword + @"
+    C : I1
+{
+    public static event System.Action M01 { add => throw null; remove {} }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<EventSymbol>().Single();
+                var m01Add = m01.AddMethod;
+                var m01Remove = m01.RemoveMethod;
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count());
+                Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (EventSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+
+                Assert.Equal("event System.Action C.M01", cM01.ToTestDisplayString());
+
+                var cM01Add = cM01.AddMethod;
+                Assert.Same(cM01Add, c.FindImplementationForInterfaceMember(m01Add));
+
+                Assert.True(cM01Add.IsStatic);
+                Assert.False(cM01Add.IsAbstract);
+                Assert.False(cM01Add.IsVirtual);
+                Assert.False(cM01Add.IsMetadataVirtual());
+                Assert.False(cM01Add.IsMetadataFinal);
+                Assert.False(cM01Add.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.EventAdd, cM01Add.MethodKind);
+                Assert.False(cM01Add.HasRuntimeSpecialName);
+                Assert.True(cM01Add.HasSpecialName);
+
+                Assert.Equal("void C.M01.add", cM01Add.ToTestDisplayString());
+
+                var cM01Remove = cM01.RemoveMethod;
+                Assert.Same(cM01Remove, c.FindImplementationForInterfaceMember(m01Remove));
+
+                Assert.True(cM01Remove.IsStatic);
+                Assert.False(cM01Remove.IsAbstract);
+                Assert.False(cM01Remove.IsVirtual);
+                Assert.False(cM01Remove.IsMetadataVirtual());
+                Assert.False(cM01Remove.IsMetadataFinal);
+                Assert.False(cM01Remove.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.EventRemove, cM01Remove.MethodKind);
+                Assert.False(cM01Remove.HasRuntimeSpecialName);
+                Assert.True(cM01Remove.HasSpecialName);
+
+                Assert.Equal("void C.M01.remove", cM01Remove.ToTestDisplayString());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                    Assert.Same(m01Add, cM01Add.ExplicitInterfaceImplementations.Single());
+                    Assert.Same(m01Remove, cM01Remove.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                    Assert.Empty(cM01Add.ExplicitInterfaceImplementations);
+                    Assert.Empty(cM01Remove.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticEvent_08(bool structure)
+        {
+            // Basic explicit implementation scenario
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action M01;
+}
+
+" + typeKeyword + @"
+    C : I1
+{
+    static event System.Action I1.M01 { add => throw null; remove {} }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<EventSymbol>().Single();
+                var m01Add = m01.AddMethod;
+                var m01Remove = m01.RemoveMethod;
+                var c = module.GlobalNamespace.GetTypeMember("C");
+
+                Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count());
+                Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var cM01 = (EventSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+
+                Assert.Equal("event System.Action C.I1.M01", cM01.ToTestDisplayString());
+
+                var cM01Add = cM01.AddMethod;
+                Assert.Same(cM01Add, c.FindImplementationForInterfaceMember(m01Add));
+
+                Assert.True(cM01Add.IsStatic);
+                Assert.False(cM01Add.IsAbstract);
+                Assert.False(cM01Add.IsVirtual);
+                Assert.False(cM01Add.IsMetadataVirtual());
+                Assert.False(cM01Add.IsMetadataFinal);
+                Assert.False(cM01Add.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.EventAdd, cM01Add.MethodKind);
+                Assert.False(cM01Add.HasRuntimeSpecialName);
+                Assert.True(cM01Add.HasSpecialName);
+
+                Assert.Equal("void C.I1.M01.add", cM01Add.ToTestDisplayString());
+
+                var cM01Remove = cM01.RemoveMethod;
+                Assert.Same(cM01Remove, c.FindImplementationForInterfaceMember(m01Remove));
+
+                Assert.True(cM01Remove.IsStatic);
+                Assert.False(cM01Remove.IsAbstract);
+                Assert.False(cM01Remove.IsVirtual);
+                Assert.False(cM01Remove.IsMetadataVirtual());
+                Assert.False(cM01Remove.IsMetadataFinal);
+                Assert.False(cM01Remove.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.EventRemove, cM01Remove.MethodKind);
+                Assert.False(cM01Remove.HasRuntimeSpecialName);
+                Assert.True(cM01Remove.HasSpecialName);
+
+                Assert.Equal("void C.I1.M01.remove", cM01Remove.ToTestDisplayString());
+
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01Add, cM01Add.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01Remove, cM01Remove.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticEvent_09()
+        {
+            // Explicit implementation from base is treated as an implementation
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action M01;
+}
+
+public class C1
+{
+    public static event System.Action M01 { add => throw null; remove {} }
+}
+
+public class C2 : C1, I1
+{
+    static event System.Action I1.M01 { add => throw null; remove {} }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                     parseOptions: parseOptions,
+                                                     targetFramework: TargetFramework.NetCoreApp,
+                                                     references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<EventSymbol>());
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+                var m01 = c3.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+
+                var cM01 = (EventSymbol)c3.FindImplementationForInterfaceMember(m01);
+
+                Assert.Equal("event System.Action C2.I1.M01", cM01.ToTestDisplayString());
+
+                Assert.Same(cM01.AddMethod, c3.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Same(cM01.RemoveMethod, c3.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+                Assert.Same(m01, cM01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.AddMethod, cM01.AddMethod.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.RemoveMethod, cM01.RemoveMethod.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticEvent_10()
+        {
+            // Implicit implementation is considered only for types implementing interface in source.
+            // In metadata, only explicit implementations are considered
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        void add_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void remove_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+    }
+
+    .event [mscorlib]System.Action M01
+    {
+        .addon void I1::add_M01(class [mscorlib]System.Action)
+        .removeon void I1::remove_M01(class [mscorlib]System.Action)
+    }
+}
+
+.class public auto ansi beforefieldinit C1
+    extends System.Object
+    implements I1
+{
+    .method private hidebysig specialname static
+        void I1.add_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        .override method void I1::add_M01(class [mscorlib]System.Action)
+        IL_0000: ret
+    }
+
+    .method private hidebysig specialname static
+        void I1.remove_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        .override method void I1::remove_M01(class [mscorlib]System.Action)
+        IL_0000: ret
+    }
+
+    .event [mscorlib]System.Action I1.M01
+    {
+        .addon void C1::I1.add_M01(class [mscorlib]System.Action)
+        .removeon void C1::I1.remove_M01(class [mscorlib]System.Action)
+    }
+
+    .method public hidebysig specialname static 
+        void add_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .method public hidebysig specialname static 
+        void remove_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .event [mscorlib]System.Action M01
+    {
+        .addon void C1::add_M01(class [mscorlib]System.Action)
+        .removeon void C1::remove_M01(class [mscorlib]System.Action)
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    }
+}
+
+.class public auto ansi beforefieldinit C2
+    extends C1
+    implements I1
+{
+    .method public hidebysig specialname static 
+        void add_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .method public hidebysig specialname static 
+        void remove_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .event [mscorlib]System.Action M01
+    {
+        .addon void C2::add_M01(class [mscorlib]System.Action)
+        .removeon void C2::remove_M01(class [mscorlib]System.Action)
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void C1::.ctor()
+        IL_0006: ret
+    }
+}
+";
+            var source1 =
+@"
+public class C3 : C2
+{
+}
+
+public class C4 : C1, I1
+{
+}
+
+public class C5 : C2, I1
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var m01 = c1.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+
+            var c1M01 = (EventSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+            Assert.Equal("event System.Action C1.I1.M01", c1M01.ToTestDisplayString());
+
+            Assert.Same(c1M01.AddMethod, c1.FindImplementationForInterfaceMember(m01.AddMethod));
+            Assert.Same(c1M01.RemoveMethod, c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+            Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+            Assert.Same(m01.AddMethod, c1M01.AddMethod.ExplicitInterfaceImplementations.Single());
+            Assert.Same(m01.RemoveMethod, c1M01.RemoveMethod.ExplicitInterfaceImplementations.Single());
+
+            var c2 = compilation1.GlobalNamespace.GetTypeMember("C2");
+            Assert.Same(c1M01, c2.FindImplementationForInterfaceMember(m01));
+            Assert.Same(c1M01.AddMethod, c2.FindImplementationForInterfaceMember(m01.AddMethod));
+            Assert.Same(c1M01.RemoveMethod, c2.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+            var c3 = compilation1.GlobalNamespace.GetTypeMember("C3");
+            Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+            Assert.Same(c1M01.AddMethod, c3.FindImplementationForInterfaceMember(m01.AddMethod));
+            Assert.Same(c1M01.RemoveMethod, c3.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+            var c4 = compilation1.GlobalNamespace.GetTypeMember("C4");
+            Assert.Same(c1M01, c4.FindImplementationForInterfaceMember(m01));
+            Assert.Same(c1M01.AddMethod, c4.FindImplementationForInterfaceMember(m01.AddMethod));
+            Assert.Same(c1M01.RemoveMethod, c4.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+            var c5 = compilation1.GlobalNamespace.GetTypeMember("C5");
+
+            var c2M01 = (EventSymbol)c5.FindImplementationForInterfaceMember(m01);
+            Assert.Equal("event System.Action C2.M01", c2M01.ToTestDisplayString());
+            Assert.Same(c2M01.AddMethod, c5.FindImplementationForInterfaceMember(m01.AddMethod));
+            Assert.Same(c2M01.RemoveMethod, c5.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticEvent_11()
+        {
+            // Ignore invalid metadata (non-abstract static virtual method). 
+            scenario1();
+            scenario2();
+            scenario3();
+
+            void scenario1()
+            {
+                var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname static virtual
+        void add_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .method public hidebysig specialname static virtual
+        void remove_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .event [mscorlib]System.Action M01
+    {
+        .addon void I1::add_M01(class [mscorlib]System.Action)
+        .removeon void I1::remove_M01(class [mscorlib]System.Action)
+    }
+}
+";
+
+                var source1 =
+@"
+public class C1 : I1
+{
+}
+";
+
+                var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation1.VerifyEmitDiagnostics();
+
+                var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+                var i1 = c1.Interfaces().Single();
+                var m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+                compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.Regular9,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation1.VerifyEmitDiagnostics();
+
+                var source2 =
+@"
+public class C1 : I1
+{
+   static event System.Action I1.M01 { add{} remove{} }
+}
+";
+
+                var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation2.VerifyEmitDiagnostics(
+                    // (4,34): error CS0539: 'C1.M01' in explicit interface declaration is not found among members of the interface that can be implemented
+                    //    static event System.Action I1.M01 { add{} remove{} }
+                    Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "M01").WithArguments("C1.M01").WithLocation(4, 34)
+                    );
+
+                c1 = compilation2.GlobalNamespace.GetTypeMember("C1");
+                m01 = c1.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+                var source3 =
+@"
+public class C1 : I1
+{
+   public static event System.Action M01 { add{} remove{} }
+}
+";
+
+                var compilation3 = CreateCompilationWithIL(source3, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation3, sourceSymbolValidator: validate3, symbolValidator: validate3, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate3(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+                    Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count());
+                    Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01));
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.AddMethod));
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                }
+            }
+
+            void scenario2()
+            {
+                var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        void add_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+    }
+
+    .method public hidebysig specialname static virtual
+        void remove_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .event [mscorlib]System.Action M01
+    {
+        .addon void I1::add_M01(class [mscorlib]System.Action)
+        .removeon void I1::remove_M01(class [mscorlib]System.Action)
+    }
+}
+";
+
+                var source1 =
+@"
+public class C1 : I1
+{
+}
+";
+
+                var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation1.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01").WithLocation(2, 19)
+                    );
+
+                var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+                var i1 = c1.Interfaces().Single();
+                var m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+                var source2 =
+@"
+public class C1 : I1
+{
+   static event System.Action I1.M01 { add {} }
+}
+";
+
+                var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation2.VerifyDiagnostics(
+                    // (4,34): error CS0065: 'C1.I1.M01': event property must have both add and remove accessors
+                    //    static event System.Action I1.M01 { add {} }
+                    Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "M01").WithArguments("C1.I1.M01").WithLocation(4, 34)
+                    );
+
+                c1 = compilation2.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                var c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Same(c1M01.AddMethod, c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.AddMethod, c1M01.AddMethod.ExplicitInterfaceImplementations.Single());
+
+                var source3 =
+@"
+public class C1 : I1
+{
+   public static event System.Action M01 { add{} remove{} }
+}
+";
+
+                var compilation3 = CreateCompilationWithIL(source3, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation3, sourceSymbolValidator: validate3, symbolValidator: validate3, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate3(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+                    var m01Add = m01.AddMethod;
+
+                    Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count());
+                    Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var cM01 = (EventSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                    Assert.True(cM01.IsStatic);
+                    Assert.False(cM01.IsAbstract);
+                    Assert.False(cM01.IsVirtual);
+
+                    Assert.Equal("event System.Action C1.M01", cM01.ToTestDisplayString());
+
+                    var cM01Add = cM01.AddMethod;
+                    Assert.Same(cM01Add, c.FindImplementationForInterfaceMember(m01Add));
+
+                    Assert.True(cM01Add.IsStatic);
+                    Assert.False(cM01Add.IsAbstract);
+                    Assert.False(cM01Add.IsVirtual);
+                    Assert.False(cM01Add.IsMetadataVirtual());
+                    Assert.False(cM01Add.IsMetadataFinal);
+                    Assert.False(cM01Add.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.EventAdd, cM01Add.MethodKind);
+
+                    Assert.Equal("void C1.M01.add", cM01Add.ToTestDisplayString());
+
+                    var cM01Remove = cM01.RemoveMethod;
+
+                    Assert.True(cM01Remove.IsStatic);
+                    Assert.False(cM01Remove.IsAbstract);
+                    Assert.False(cM01Remove.IsVirtual);
+                    Assert.False(cM01Remove.IsMetadataVirtual());
+                    Assert.False(cM01Remove.IsMetadataFinal);
+                    Assert.False(cM01Remove.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.EventRemove, cM01Remove.MethodKind);
+
+                    Assert.Equal("void C1.M01.remove", cM01Remove.ToTestDisplayString());
+
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+                    if (module is PEModuleSymbol)
+                    {
+                        Assert.Same(m01Add, cM01Add.ExplicitInterfaceImplementations.Single());
+                    }
+                    else
+                    {
+                        Assert.Empty(cM01Add.ExplicitInterfaceImplementations);
+                    }
+
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                    Assert.Empty(cM01Remove.ExplicitInterfaceImplementations);
+                }
+
+                var source4 =
+@"
+public class C1 : I1
+{
+   static event System.Action I1.M01 { add{} remove{} }
+}
+";
+
+                var compilation4 = CreateCompilationWithIL(source4, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation4.VerifyDiagnostics(
+                    // (4,46): error CS0550: 'C1.I1.M01.remove' adds an accessor not found in interface member 'I1.M01'
+                    //    static event System.Action I1.M01 { add{} remove{} }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "remove").WithArguments("C1.I1.M01.remove", "I1.M01").WithLocation(4, 46)
+                    );
+
+                c1 = compilation4.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Same(c1M01.AddMethod, c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.AddMethod, c1M01.AddMethod.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.RemoveMethod, c1M01.RemoveMethod.ExplicitInterfaceImplementations.Single());
+
+                var source5 =
+@"
+public class C1 : I1
+{
+   public static event System.Action M01 { add{} }
+}
+";
+
+                var compilation5 = CreateCompilationWithIL(source5, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation5.VerifyDiagnostics(
+                    // (4,38): error CS0065: 'C1.M01': event property must have both add and remove accessors
+                    //    public static event System.Action M01 { add{} }
+                    Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "M01").WithArguments("C1.M01").WithLocation(4, 38)
+                    );
+
+                c1 = compilation5.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Same(c1M01.AddMethod, c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+                var source6 =
+@"
+public class C1 : I1
+{
+   public static event System.Action M01 { remove{} }
+}
+";
+
+                var compilation6 = CreateCompilationWithIL(source6, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation6.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01.add'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01.add").WithLocation(2, 19),
+                    // (4,38): error CS0065: 'C1.M01': event property must have both add and remove accessors
+                    //    public static event System.Action M01 { remove{} }
+                    Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "M01").WithArguments("C1.M01").WithLocation(4, 38)
+                    );
+
+                c1 = compilation6.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+                var source7 =
+@"
+public class C1 : I1
+{
+   static event System.Action I1.M01 { remove{} }
+}
+";
+
+                var compilation7 = CreateCompilationWithIL(source7, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation7.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01.add'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01.add").WithLocation(2, 19),
+                    // (4,34): error CS0065: 'C1.I1.M01': event property must have both add and remove accessors
+                    //    static event System.Action I1.M01 { remove{} }
+                    Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "M01").WithArguments("C1.I1.M01").WithLocation(4, 34),
+                    // (4,40): error CS0550: 'C1.I1.M01.remove' adds an accessor not found in interface member 'I1.M01'
+                    //    static event System.Action I1.M01 { remove{} }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "remove").WithArguments("C1.I1.M01.remove", "I1.M01").WithLocation(4, 40)
+                    );
+
+                c1 = compilation7.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.RemoveMethod, c1M01.RemoveMethod.ExplicitInterfaceImplementations.Single());
+            }
+
+            void scenario3()
+            {
+                var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname static virtual
+        void add_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        IL_0000: ret
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void remove_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+    }
+
+    .event [mscorlib]System.Action M01
+    {
+        .addon void I1::add_M01(class [mscorlib]System.Action)
+        .removeon void I1::remove_M01(class [mscorlib]System.Action)
+    }
+}
+";
+
+                var source1 =
+@"
+public class C1 : I1
+{
+}
+";
+
+                var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation1.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01").WithLocation(2, 19)
+                    );
+
+                var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+                var i1 = c1.Interfaces().Single();
+                var m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(i1.FindImplementationForInterfaceMember(m01.AddMethod));
+
+                var source2 =
+@"
+public class C1 : I1
+{
+   static event System.Action I1.M01 { remove {} }
+}
+";
+
+                var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation2.VerifyDiagnostics(
+                    // (4,34): error CS0065: 'C1.I1.M01': event property must have both add and remove accessors
+                    //    static event System.Action I1.M01 { add {} }
+                    Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "M01").WithArguments("C1.I1.M01").WithLocation(4, 34)
+                    );
+
+                c1 = compilation2.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                var c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Same(c1M01.RemoveMethod, c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.RemoveMethod, c1M01.RemoveMethod.ExplicitInterfaceImplementations.Single());
+
+                var source3 =
+@"
+public class C1 : I1
+{
+   public static event System.Action M01 { add{} remove{} }
+}
+";
+
+                var compilation3 = CreateCompilationWithIL(source3, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                CompileAndVerify(compilation3, sourceSymbolValidator: validate3, symbolValidator: validate3, verify: Verification.Skipped).VerifyDiagnostics();
+
+                void validate3(ModuleSymbol module)
+                {
+                    var c = module.GlobalNamespace.GetTypeMember("C1");
+
+                    var m01 = c.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+                    var m01Remove = m01.RemoveMethod;
+
+                    Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count());
+                    Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                    var cM01 = (EventSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                    Assert.True(cM01.IsStatic);
+                    Assert.False(cM01.IsAbstract);
+                    Assert.False(cM01.IsVirtual);
+
+                    Assert.Equal("event System.Action C1.M01", cM01.ToTestDisplayString());
+
+                    var cM01Remove = cM01.RemoveMethod;
+                    Assert.Same(cM01Remove, c.FindImplementationForInterfaceMember(m01Remove));
+
+                    Assert.True(cM01Remove.IsStatic);
+                    Assert.False(cM01Remove.IsAbstract);
+                    Assert.False(cM01Remove.IsVirtual);
+                    Assert.False(cM01Remove.IsMetadataVirtual());
+                    Assert.False(cM01Remove.IsMetadataFinal);
+                    Assert.False(cM01Remove.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.EventRemove, cM01Remove.MethodKind);
+
+                    Assert.Equal("void C1.M01.remove", cM01Remove.ToTestDisplayString());
+
+                    var cM01Add = cM01.AddMethod;
+
+                    Assert.True(cM01Add.IsStatic);
+                    Assert.False(cM01Add.IsAbstract);
+                    Assert.False(cM01Add.IsVirtual);
+                    Assert.False(cM01Add.IsMetadataVirtual());
+                    Assert.False(cM01Add.IsMetadataFinal);
+                    Assert.False(cM01Add.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.EventAdd, cM01Add.MethodKind);
+
+                    Assert.Equal("void C1.M01.add", cM01Add.ToTestDisplayString());
+
+                    Assert.Null(c.FindImplementationForInterfaceMember(m01.AddMethod));
+
+                    if (module is PEModuleSymbol)
+                    {
+                        Assert.Same(m01Remove, cM01Remove.ExplicitInterfaceImplementations.Single());
+                    }
+                    else
+                    {
+                        Assert.Empty(cM01Remove.ExplicitInterfaceImplementations);
+                    }
+
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                    Assert.Empty(cM01Add.ExplicitInterfaceImplementations);
+                }
+
+                var source4 =
+@"
+public class C1 : I1
+{
+   static event System.Action I1.M01 { add{} remove{} }
+}
+";
+
+                var compilation4 = CreateCompilationWithIL(source4, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation4.VerifyDiagnostics(
+                    // (4,40): error CS0550: 'C1.I1.M01.add' adds an accessor not found in interface member 'I1.M01'
+                    //    static event System.Action I1.M01 { add{} remove{} }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "add").WithArguments("C1.I1.M01.add", "I1.M01").WithLocation(4, 40)
+                    );
+
+                c1 = compilation4.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Same(c1M01.RemoveMethod, c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.RemoveMethod, c1M01.RemoveMethod.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.AddMethod, c1M01.AddMethod.ExplicitInterfaceImplementations.Single());
+
+                var source5 =
+@"
+public class C1 : I1
+{
+   public static event System.Action M01 { remove{} }
+}
+";
+
+                var compilation5 = CreateCompilationWithIL(source5, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation5.VerifyDiagnostics(
+                    // (4,38): error CS0065: 'C1.M01': event property must have both add and remove accessors
+                    //    public static event System.Action M01 { remove{} }
+                    Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "M01").WithArguments("C1.M01").WithLocation(4, 38)
+                    );
+
+                c1 = compilation5.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Same(c1M01.RemoveMethod, c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+
+                var source6 =
+@"
+public class C1 : I1
+{
+   public static event System.Action M01 { add{} }
+}
+";
+
+                var compilation6 = CreateCompilationWithIL(source6, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation6.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01.remove'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01.remove").WithLocation(2, 19),
+                    // (4,38): error CS0065: 'C1.M01': event property must have both add and remove accessors
+                    //    public static event System.Action M01 { remove{} }
+                    Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "M01").WithArguments("C1.M01").WithLocation(4, 38)
+                    );
+
+                c1 = compilation6.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+                var source7 =
+@"
+public class C1 : I1
+{
+   static event System.Action I1.M01 { add{} }
+}
+";
+
+                var compilation7 = CreateCompilationWithIL(source7, ilSource, options: TestOptions.DebugDll,
+                                                     parseOptions: TestOptions.RegularPreview,
+                                                     targetFramework: TargetFramework.NetCoreApp);
+
+                compilation7.VerifyDiagnostics(
+                    // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01.remove'
+                    // public class C1 : I1
+                    Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1").WithArguments("C1", "I1.M01.remove").WithLocation(2, 19),
+                    // (4,34): error CS0065: 'C1.I1.M01': event property must have both add and remove accessors
+                    //    static event System.Action I1.M01 { add{} }
+                    Diagnostic(ErrorCode.ERR_EventNeedsBothAccessors, "M01").WithArguments("C1.I1.M01").WithLocation(4, 34),
+                    // (4,40): error CS0550: 'C1.I1.M01.add' adds an accessor not found in interface member 'I1.M01'
+                    //    static event System.Action I1.M01 { add{} }
+                    Diagnostic(ErrorCode.ERR_ExplicitPropertyAddingAccessor, "add").WithArguments("C1.I1.M01.add", "I1.M01").WithLocation(4, 40)
+                    );
+
+                c1 = compilation7.GlobalNamespace.GetTypeMember("C1");
+                i1 = c1.Interfaces().Single();
+                m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+                c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(m01.AddMethod, c1M01.AddMethod.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticEvent_12()
+        {
+            // Ignore invalid metadata (default interface implementation for a static method)
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        void add_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void remove_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+    }
+
+    .event [mscorlib]System.Action M01
+    {
+        .addon void I1::add_M01(class [mscorlib]System.Action)
+        .removeon void I1::remove_M01(class [mscorlib]System.Action)
+    }
+}
+
+.class interface public auto ansi abstract I2
+    implements I1
+{
+    .method private hidebysig specialname static
+        void I1.add_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        .override method void I1::add_M01(class [mscorlib]System.Action)
+        IL_0000: ret
+    }
+
+    .method private hidebysig specialname static
+        void I1.remove_M01 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+        .override method void I1::remove_M01(class [mscorlib]System.Action)
+        IL_0000: ret
+    }
+
+    .event [mscorlib]System.Action I1.M01
+    {
+        .addon void I2::I1.add_M01(class [mscorlib]System.Action)
+        .removeon void I2::I1.remove_M01(class [mscorlib]System.Action)
+    }
+}
+";
+
+            var source1 =
+@"
+public class C1 : I2
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics(
+                // (2,19): error CS0535: 'C1' does not implement interface member 'I1.M01'
+                // public class C1 : I2
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2").WithArguments("C1", "I1.M01").WithLocation(2, 19)
+                );
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i2 = c1.Interfaces().Single();
+            var i1 = i2.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<EventSymbol>().Single();
+
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01));
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01.AddMethod));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01.AddMethod));
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+            var i2M01 = i2.GetMembers().OfType<EventSymbol>().Single();
+            Assert.Same(m01, i2M01.ExplicitInterfaceImplementations.Single());
+            Assert.Same(m01.AddMethod, i2M01.AddMethod.ExplicitInterfaceImplementations.Single());
+            Assert.Same(m01.RemoveMethod, i2M01.RemoveMethod.ExplicitInterfaceImplementations.Single());
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticEvent_13()
+        {
+            // A forwarding method is added for an implicit implementation declared in base class. 
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action M01;
+}
+
+class C1
+{
+    public static event System.Action M01 { add => throw null; remove{} }
+}
+
+class C2 : C1, I1
+{
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var m01 = module.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<EventSymbol>().Single();
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+
+                var c2M01 = (EventSymbol)c2.FindImplementationForInterfaceMember(m01);
+                var c2M01Add = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01.AddMethod);
+                var c2M01Remove = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01.RemoveMethod);
+
+                Assert.True(c2M01Add.IsStatic);
+                Assert.False(c2M01Add.IsAbstract);
+                Assert.False(c2M01Add.IsVirtual);
+                Assert.False(c2M01Add.IsMetadataVirtual());
+                Assert.False(c2M01Add.IsMetadataFinal);
+                Assert.False(c2M01Add.IsMetadataNewSlot());
+
+                Assert.True(c2M01Remove.IsStatic);
+                Assert.False(c2M01Remove.IsAbstract);
+                Assert.False(c2M01Remove.IsVirtual);
+                Assert.False(c2M01Remove.IsMetadataVirtual());
+                Assert.False(c2M01Remove.IsMetadataFinal);
+                Assert.False(c2M01Remove.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01Add.MethodKind);
+                    Assert.False(c2M01Add.HasRuntimeSpecialName);
+                    Assert.False(c2M01Add.HasSpecialName);
+                    Assert.Equal("void C2.I1.add_M01(System.Action value)", c2M01Add.ToTestDisplayString());
+                    Assert.Same(m01.AddMethod, c2M01Add.ExplicitInterfaceImplementations.Single());
+
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01Remove.MethodKind);
+                    Assert.False(c2M01Remove.HasRuntimeSpecialName);
+                    Assert.False(c2M01Remove.HasSpecialName);
+                    Assert.Equal("void C2.I1.remove_M01(System.Action value)", c2M01Remove.ToTestDisplayString());
+                    Assert.Same(m01.RemoveMethod, c2M01Remove.ExplicitInterfaceImplementations.Single());
+
+                    // Forwarding methods for accessors aren't tied to a property
+                    Assert.Null(c2M01);
+
+                    var c1M01 = module.GlobalNamespace.GetMember<EventSymbol>("C1.M01");
+                    var c1M01Add = c1M01.AddMethod;
+                    var c1M01Remove = c1M01.RemoveMethod;
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+
+                    Assert.True(c1M01Add.IsStatic);
+                    Assert.False(c1M01Add.IsAbstract);
+                    Assert.False(c1M01Add.IsVirtual);
+                    Assert.False(c1M01Add.IsMetadataVirtual());
+                    Assert.False(c1M01Add.IsMetadataFinal);
+                    Assert.False(c1M01Add.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.EventAdd, c1M01Add.MethodKind);
+                    Assert.False(c1M01Add.HasRuntimeSpecialName);
+                    Assert.True(c1M01Add.HasSpecialName);
+                    Assert.Empty(c1M01Add.ExplicitInterfaceImplementations);
+
+                    Assert.True(c1M01Remove.IsStatic);
+                    Assert.False(c1M01Remove.IsAbstract);
+                    Assert.False(c1M01Remove.IsVirtual);
+                    Assert.False(c1M01Remove.IsMetadataVirtual());
+                    Assert.False(c1M01Remove.IsMetadataFinal);
+                    Assert.False(c1M01Remove.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.EventRemove, c1M01Remove.MethodKind);
+                    Assert.False(c1M01Remove.HasRuntimeSpecialName);
+                    Assert.True(c1M01Remove.HasSpecialName);
+                    Assert.Empty(c1M01Remove.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.True(c2M01.IsStatic);
+                    Assert.False(c2M01.IsAbstract);
+                    Assert.False(c2M01.IsVirtual);
+
+                    Assert.Equal("event System.Action C1.M01", c2M01.ToTestDisplayString());
+                    Assert.Empty(c2M01.ExplicitInterfaceImplementations);
+
+                    Assert.Equal(MethodKind.EventAdd, c2M01Add.MethodKind);
+                    Assert.False(c2M01Add.HasRuntimeSpecialName);
+                    Assert.True(c2M01Add.HasSpecialName);
+                    Assert.Same(c2M01.AddMethod, c2M01Add);
+                    Assert.Empty(c2M01Add.ExplicitInterfaceImplementations);
+
+                    Assert.Equal(MethodKind.EventRemove, c2M01Remove.MethodKind);
+                    Assert.False(c2M01Remove.HasRuntimeSpecialName);
+                    Assert.True(c2M01Remove.HasSpecialName);
+                    Assert.Same(c2M01.RemoveMethod, c2M01Remove);
+                    Assert.Empty(c2M01Remove.ExplicitInterfaceImplementations);
+                }
+            }
+
+            verifier.VerifyIL("C2.I1.add_M01",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C1.M01.add""
+  IL_0006:  ret
+}
+");
+
+            verifier.VerifyIL("C2.I1.remove_M01",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C1.M01.remove""
+  IL_0006:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticEvent_14()
+        {
+            // A forwarding method is added for an implicit implementation with modopt mismatch. 
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig specialname abstract virtual static 
+        void add_M01 (
+            class [mscorlib]System.Action`1<int32 modopt(I1)> 'value'
+        ) cil managed 
+    {
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void remove_M01 (
+            class [mscorlib]System.Action`1<int32 modopt(I1)> 'value'
+        ) cil managed 
+    {
+    }
+
+    .event class [mscorlib]System.Action`1<int32 modopt(I1)> M01
+    {
+        .addon void I1::add_M01(class [mscorlib]System.Action`1<int32 modopt(I1)>)
+        .removeon void I1::remove_M01(class [mscorlib]System.Action`1<int32 modopt(I1)>)
+    }
+}
+
+.class interface public auto ansi abstract I2
+{
+    .method public hidebysig specialname abstract virtual static 
+        void add_M02 (
+            class [mscorlib]System.Action modopt(I1) 'value'
+        ) cil managed 
+    {
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        void modopt(I2) remove_M02 (
+            class [mscorlib]System.Action 'value'
+        ) cil managed 
+    {
+    }
+
+    .event class [mscorlib]System.Action M02
+    {
+        .addon void I2::add_M02(class [mscorlib]System.Action modopt(I1))
+        .removeon void modopt(I2) I2::remove_M02(class [mscorlib]System.Action)
+    }
+}
+";
+
+            var source1 =
+@"
+class C1 : I1
+{
+    public static event System.Action<int> M01 { add => throw null; remove{} }
+}
+
+class C2 : I1
+{
+    static event System.Action<int> I1.M01 { add => throw null; remove{} }
+}
+
+#pragma warning disable CS0067 // The event 'C3.M02' is never used
+
+class C3 : I2
+{
+    public static event System.Action M02;
+}
+
+class C4 : I2
+{
+    static event System.Action I2.M02 { add => throw null; remove{} }
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c1 = module.GlobalNamespace.GetTypeMember("C1");
+                var m01 = c1.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+
+                var c1M01 = c1.GetMembers().OfType<EventSymbol>().Single();
+                var c1M01Add = c1M01.AddMethod;
+                var c1M01Remove = c1M01.RemoveMethod;
+
+                Assert.Equal("event System.Action<System.Int32> C1.M01", c1M01.ToTestDisplayString());
+                Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+
+                Assert.Equal(MethodKind.EventAdd, c1M01Add.MethodKind);
+                Assert.Equal("void C1.M01.add", c1M01Add.ToTestDisplayString());
+                Assert.Equal("System.Action<System.Int32> value", c1M01Add.Parameters.Single().ToTestDisplayString());
+                Assert.Empty(c1M01Add.ExplicitInterfaceImplementations);
+                Assert.True(c1M01Add.IsStatic);
+                Assert.False(c1M01Add.IsAbstract);
+                Assert.False(c1M01Add.IsVirtual);
+                Assert.False(c1M01Add.IsMetadataVirtual());
+                Assert.False(c1M01Add.IsMetadataFinal);
+                Assert.False(c1M01Add.IsMetadataNewSlot());
+
+                Assert.Equal(MethodKind.EventRemove, c1M01Remove.MethodKind);
+                Assert.Equal("void C1.M01.remove", c1M01Remove.ToTestDisplayString());
+                Assert.Equal("System.Action<System.Int32> value", c1M01Remove.Parameters.Single().ToTestDisplayString());
+                Assert.Empty(c1M01Remove.ExplicitInterfaceImplementations);
+                Assert.True(c1M01Remove.IsStatic);
+                Assert.False(c1M01Remove.IsAbstract);
+                Assert.False(c1M01Remove.IsVirtual);
+                Assert.False(c1M01Remove.IsMetadataVirtual());
+                Assert.False(c1M01Remove.IsMetadataFinal);
+                Assert.False(c1M01Remove.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    c1M01Add = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01.AddMethod);
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01Add.MethodKind);
+                    Assert.Equal("void C1.I1.add_M01(System.Action<System.Int32 modopt(I1)> value)", c1M01Add.ToTestDisplayString());
+                    Assert.Same(m01.AddMethod, c1M01Add.ExplicitInterfaceImplementations.Single());
+
+                    Assert.True(c1M01Add.IsStatic);
+                    Assert.False(c1M01Add.IsAbstract);
+                    Assert.False(c1M01Add.IsVirtual);
+                    Assert.False(c1M01Add.IsMetadataVirtual());
+                    Assert.False(c1M01Add.IsMetadataFinal);
+                    Assert.False(c1M01Add.IsMetadataNewSlot());
+
+                    c1M01Remove = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01.RemoveMethod);
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01Remove.MethodKind);
+                    Assert.Equal("void C1.I1.remove_M01(System.Action<System.Int32 modopt(I1)> value)", c1M01Remove.ToTestDisplayString());
+                    Assert.Same(m01.RemoveMethod, c1M01Remove.ExplicitInterfaceImplementations.Single());
+
+                    Assert.True(c1M01Remove.IsStatic);
+                    Assert.False(c1M01Remove.IsAbstract);
+                    Assert.False(c1M01Remove.IsVirtual);
+                    Assert.False(c1M01Remove.IsMetadataVirtual());
+                    Assert.False(c1M01Remove.IsMetadataFinal);
+                    Assert.False(c1M01Remove.IsMetadataNewSlot());
+
+                    // Forwarding methods aren't tied to an event  
+                    Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+                }
+                else
+                {
+                    Assert.Same(c1M01, c1.FindImplementationForInterfaceMember(m01));
+                    Assert.Same(c1M01Add, c1.FindImplementationForInterfaceMember(m01.AddMethod));
+                    Assert.Same(c1M01Remove, c1.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                }
+
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+
+                var c2M01 = (EventSymbol)c2.FindImplementationForInterfaceMember(m01);
+                var c2M01Add = c2M01.AddMethod;
+                var c2M01Remove = c2M01.RemoveMethod;
+
+                Assert.Equal("event System.Action<System.Int32 modopt(I1)> C2.I1.M01", c2M01.ToTestDisplayString());
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.Same(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                Assert.True(c2M01Add.IsStatic);
+                Assert.False(c2M01Add.IsAbstract);
+                Assert.False(c2M01Add.IsVirtual);
+                Assert.False(c2M01Add.IsMetadataVirtual());
+                Assert.False(c2M01Add.IsMetadataFinal);
+                Assert.False(c2M01Add.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.EventAdd, c2M01Add.MethodKind);
+                Assert.Equal("void C2.I1.M01.add", c2M01Add.ToTestDisplayString());
+                Assert.Equal("System.Action<System.Int32 modopt(I1)> value", c2M01Add.Parameters.Single().ToTestDisplayString());
+                Assert.Same(m01.AddMethod, c2M01Add.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c2M01Add, c2.FindImplementationForInterfaceMember(m01.AddMethod));
+
+                Assert.True(c2M01Remove.IsStatic);
+                Assert.False(c2M01Remove.IsAbstract);
+                Assert.False(c2M01Remove.IsVirtual);
+                Assert.False(c2M01Remove.IsMetadataVirtual());
+                Assert.False(c2M01Remove.IsMetadataFinal);
+                Assert.False(c2M01Remove.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.EventRemove, c2M01Remove.MethodKind);
+                Assert.Equal("void C2.I1.M01.remove", c2M01Remove.ToTestDisplayString());
+                Assert.Equal("System.Action<System.Int32 modopt(I1)> value", c2M01Remove.Parameters.Single().ToTestDisplayString());
+                Assert.Same(m01.RemoveMethod, c2M01Remove.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c2M01Remove, c2.FindImplementationForInterfaceMember(m01.RemoveMethod));
+
+                Assert.Same(c2M01, c2.GetMembers().OfType<EventSymbol>().Single());
+                Assert.Equal(2, c2.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                var m02 = c3.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+
+                var c3M02 = c3.GetMembers().OfType<EventSymbol>().Single();
+                var c3M02Add = c3M02.AddMethod;
+                var c3M02Remove = c3M02.RemoveMethod;
+
+                Assert.Equal("event System.Action C3.M02", c3M02.ToTestDisplayString());
+                Assert.Empty(c3M02.ExplicitInterfaceImplementations);
+                Assert.True(c3M02.IsStatic);
+                Assert.False(c3M02.IsAbstract);
+                Assert.False(c3M02.IsVirtual);
+
+                Assert.Equal(MethodKind.EventAdd, c3M02Add.MethodKind);
+                Assert.Equal("void C3.M02.add", c3M02Add.ToTestDisplayString());
+                Assert.Equal("System.Action value", c3M02Add.Parameters.Single().ToTestDisplayString());
+                Assert.Empty(c3M02Add.ExplicitInterfaceImplementations);
+                Assert.True(c3M02Add.IsStatic);
+                Assert.False(c3M02Add.IsAbstract);
+                Assert.False(c3M02Add.IsVirtual);
+                Assert.False(c3M02Add.IsMetadataVirtual());
+                Assert.False(c3M02Add.IsMetadataFinal);
+                Assert.False(c3M02Add.IsMetadataNewSlot());
+
+                Assert.Equal(MethodKind.EventRemove, c3M02Remove.MethodKind);
+                Assert.Equal("void C3.M02.remove", c3M02Remove.ToTestDisplayString());
+                Assert.Equal("System.Void", c3M02Remove.ReturnTypeWithAnnotations.ToTestDisplayString());
+                Assert.Empty(c3M02Remove.ExplicitInterfaceImplementations);
+                Assert.True(c3M02Remove.IsStatic);
+                Assert.False(c3M02Remove.IsAbstract);
+                Assert.False(c3M02Remove.IsVirtual);
+                Assert.False(c3M02Remove.IsMetadataVirtual());
+                Assert.False(c3M02Remove.IsMetadataFinal);
+                Assert.False(c3M02Remove.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    c3M02Add = (MethodSymbol)c3.FindImplementationForInterfaceMember(m02.AddMethod);
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c3M02Add.MethodKind);
+                    Assert.Equal("void C3.I2.add_M02(System.Action modopt(I1) value)", c3M02Add.ToTestDisplayString());
+                    Assert.Same(m02.AddMethod, c3M02Add.ExplicitInterfaceImplementations.Single());
+
+                    Assert.True(c3M02Add.IsStatic);
+                    Assert.False(c3M02Add.IsAbstract);
+                    Assert.False(c3M02Add.IsVirtual);
+                    Assert.False(c3M02Add.IsMetadataVirtual());
+                    Assert.False(c3M02Add.IsMetadataFinal);
+                    Assert.False(c3M02Add.IsMetadataNewSlot());
+
+                    c3M02Remove = (MethodSymbol)c3.FindImplementationForInterfaceMember(m02.RemoveMethod);
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c3M02Remove.MethodKind);
+                    Assert.Equal("void modopt(I2) C3.I2.remove_M02(System.Action value)", c3M02Remove.ToTestDisplayString());
+                    Assert.Same(m02.RemoveMethod, c3M02Remove.ExplicitInterfaceImplementations.Single());
+
+                    Assert.True(c3M02Remove.IsStatic);
+                    Assert.False(c3M02Remove.IsAbstract);
+                    Assert.False(c3M02Remove.IsVirtual);
+                    Assert.False(c3M02Remove.IsMetadataVirtual());
+                    Assert.False(c3M02Remove.IsMetadataFinal);
+                    Assert.False(c3M02Remove.IsMetadataNewSlot());
+
+                    // Forwarding methods aren't tied to an event  
+                    Assert.Null(c3.FindImplementationForInterfaceMember(m02));
+                }
+                else
+                {
+                    Assert.Same(c3M02, c3.FindImplementationForInterfaceMember(m02));
+                    Assert.Same(c3M02Add, c3.FindImplementationForInterfaceMember(m02.AddMethod));
+                    Assert.Same(c3M02Remove, c3.FindImplementationForInterfaceMember(m02.RemoveMethod));
+                }
+
+                var c4 = module.GlobalNamespace.GetTypeMember("C4");
+
+                var c4M02 = (EventSymbol)c4.FindImplementationForInterfaceMember(m02);
+                var c4M02Add = c4M02.AddMethod;
+                var c4M02Remove = c4M02.RemoveMethod;
+
+                Assert.Equal("event System.Action C4.I2.M02", c4M02.ToTestDisplayString());
+
+                // Signatures of accessors are lacking custom modifiers due to https://github.com/dotnet/roslyn/issues/53390.
+
+                Assert.True(c4M02.IsStatic);
+                Assert.False(c4M02.IsAbstract);
+                Assert.False(c4M02.IsVirtual);
+                Assert.Same(m02, c4M02.ExplicitInterfaceImplementations.Single());
+
+                Assert.True(c4M02Add.IsStatic);
+                Assert.False(c4M02Add.IsAbstract);
+                Assert.False(c4M02Add.IsVirtual);
+                Assert.False(c4M02Add.IsMetadataVirtual());
+                Assert.False(c4M02Add.IsMetadataFinal);
+                Assert.False(c4M02Add.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.EventAdd, c4M02Add.MethodKind);
+                Assert.Equal("void C4.I2.M02.add", c4M02Add.ToTestDisplayString());
+                Assert.Equal("System.Action value", c4M02Add.Parameters.Single().ToTestDisplayString());
+                Assert.Equal("System.Void", c4M02Add.ReturnTypeWithAnnotations.ToTestDisplayString());
+                Assert.Same(m02.AddMethod, c4M02Add.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c4M02Add, c4.FindImplementationForInterfaceMember(m02.AddMethod));
+
+                Assert.True(c4M02Remove.IsStatic);
+                Assert.False(c4M02Remove.IsAbstract);
+                Assert.False(c4M02Remove.IsVirtual);
+                Assert.False(c4M02Remove.IsMetadataVirtual());
+                Assert.False(c4M02Remove.IsMetadataFinal);
+                Assert.False(c4M02Remove.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.EventRemove, c4M02Remove.MethodKind);
+                Assert.Equal("void C4.I2.M02.remove", c4M02Remove.ToTestDisplayString());
+                Assert.Equal("System.Action value", c4M02Remove.Parameters.Single().ToTestDisplayString());
+                Assert.Equal("System.Void", c4M02Remove.ReturnTypeWithAnnotations.ToTestDisplayString());
+                Assert.Same(m02.RemoveMethod, c4M02Remove.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c4M02Remove, c4.FindImplementationForInterfaceMember(m02.RemoveMethod));
+
+                Assert.Same(c4M02, c4.GetMembers().OfType<EventSymbol>().Single());
+                Assert.Equal(2, c4.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+            }
+
+            verifier.VerifyIL("C1.I1.add_M01",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C1.M01.add""
+  IL_0006:  ret
+}
+");
+
+            verifier.VerifyIL("C1.I1.remove_M01",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C1.M01.remove""
+  IL_0006:  ret
+}
+");
+
+            verifier.VerifyIL("C3.I2.add_M02",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C3.M02.add""
+  IL_0006:  ret
+}
+");
+
+            verifier.VerifyIL("C3.I2.remove_M02",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C3.M02.remove""
+  IL_0006:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticEvent_15()
+        {
+            // A forwarding method isn't created if base class implements interface exactly the same way. 
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action M01;
+    abstract static event System.Action M02;
+}
+
+public class C1
+{
+    public static event System.Action M01 { add => throw null; remove{} }
+}
+
+public class C2 : C1, I1
+{
+    static event System.Action I1.M02 { add => throw null; remove{} }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.RegularPreview, TestOptions.Regular9 })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<EventSymbol>());
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+
+                var m01 = c3.Interfaces().Single().GetMembers("M01").OfType<EventSymbol>().Single();
+
+                var c1M01 = c3.BaseType().BaseType().GetMember<EventSymbol>("M01");
+                Assert.Equal("event System.Action C1.M01", c1M01.ToTestDisplayString());
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+
+                Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+
+                var c1M01Add = c1M01.AddMethod;
+                Assert.True(c1M01Add.IsStatic);
+                Assert.False(c1M01Add.IsAbstract);
+                Assert.False(c1M01Add.IsVirtual);
+                Assert.False(c1M01Add.IsMetadataVirtual());
+                Assert.False(c1M01Add.IsMetadataFinal);
+                Assert.False(c1M01Add.IsMetadataNewSlot());
+
+                Assert.Empty(c1M01Add.ExplicitInterfaceImplementations);
+
+                var c1M01Remove = c1M01.RemoveMethod;
+                Assert.True(c1M01Remove.IsStatic);
+                Assert.False(c1M01Remove.IsAbstract);
+                Assert.False(c1M01Remove.IsVirtual);
+                Assert.False(c1M01Remove.IsMetadataVirtual());
+                Assert.False(c1M01Remove.IsMetadataFinal);
+                Assert.False(c1M01Remove.IsMetadataNewSlot());
+
+                Assert.Empty(c1M01Remove.ExplicitInterfaceImplementations);
+
+                if (c1M01.ContainingModule is PEModuleSymbol)
+                {
+                    var c2M01Add = c3.FindImplementationForInterfaceMember(m01.AddMethod);
+                    Assert.Equal("void C2.I1.add_M01(System.Action value)", c2M01Add.ToTestDisplayString());
+
+                    var c2M01Remove = c3.FindImplementationForInterfaceMember(m01.RemoveMethod);
+                    Assert.Equal("void C2.I1.remove_M01(System.Action value)", c2M01Remove.ToTestDisplayString());
+
+                    // Forwarding methods for accessors aren't tied to an event
+                    Assert.Null(c3.FindImplementationForInterfaceMember(m01));
+                }
+                else
+                {
+                    Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+                    Assert.Same(c1M01.AddMethod, c3.FindImplementationForInterfaceMember(m01.AddMethod));
+                    Assert.Same(c1M01.RemoveMethod, c3.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                }
+
+                var m02 = c3.Interfaces().Single().GetMembers("M02").OfType<EventSymbol>().Single();
+
+                var c2M02 = c3.BaseType().GetMember<EventSymbol>("I1.M02");
+                Assert.Equal("event System.Action C2.I1.M02", c2M02.ToTestDisplayString());
+                Assert.Same(c2M02, c3.FindImplementationForInterfaceMember(m02));
+                Assert.Same(c2M02.AddMethod, c3.FindImplementationForInterfaceMember(m02.AddMethod));
+                Assert.Same(c2M02.RemoveMethod, c3.FindImplementationForInterfaceMember(m02.RemoveMethod));
+            }
+        }
+
+        [Fact]
+        public void ImplementAbstractStaticEvent_16()
+        {
+            // A new implicit implementation is properly considered.
+
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action M01;
+}
+
+public class C1 : I1
+{
+    public static event System.Action M01 { add{} remove => throw null; }
+}
+
+public class C2 : C1
+{
+    new public static event System.Action M01 { add{} remove => throw null; }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    var verifier = CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+                    verifier.VerifyIL("C3.I1.add_M01",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C2.M01.add""
+  IL_0006:  ret
+}
+");
+
+                    verifier.VerifyIL("C3.I1.remove_M01",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""void C2.M01.remove""
+  IL_0006:  ret
+}
+");
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                var m01 = c3.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+
+                var c2M01 = c3.BaseType().GetMember<EventSymbol>("M01");
+                var c2M01Add = c2M01.AddMethod;
+                var c2M01Remove = c2M01.RemoveMethod;
+                Assert.Equal("event System.Action C2.M01", c2M01.ToTestDisplayString());
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.Empty(c2M01.ExplicitInterfaceImplementations);
+
+                Assert.True(c2M01Add.IsStatic);
+                Assert.False(c2M01Add.IsAbstract);
+                Assert.False(c2M01Add.IsVirtual);
+                Assert.False(c2M01Add.IsMetadataVirtual());
+                Assert.False(c2M01Add.IsMetadataFinal);
+                Assert.False(c2M01Add.IsMetadataNewSlot());
+                Assert.Empty(c2M01Add.ExplicitInterfaceImplementations);
+
+                Assert.True(c2M01Remove.IsStatic);
+                Assert.False(c2M01Remove.IsAbstract);
+                Assert.False(c2M01Remove.IsVirtual);
+                Assert.False(c2M01Remove.IsMetadataVirtual());
+                Assert.False(c2M01Remove.IsMetadataFinal);
+                Assert.False(c2M01Remove.IsMetadataNewSlot());
+                Assert.Empty(c2M01Remove.ExplicitInterfaceImplementations);
+
+                if (module is PEModuleSymbol)
+                {
+                    var c3M01 = (EventSymbol)c3.FindImplementationForInterfaceMember(m01);
+                    // Forwarding methods for accessors aren't tied to an event
+                    Assert.Null(c3M01);
+
+                    var c3M01Add = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01.AddMethod);
+                    Assert.Equal("void C3.I1.add_M01(System.Action value)", c3M01Add.ToTestDisplayString());
+                    Assert.Same(m01.AddMethod, c3M01Add.ExplicitInterfaceImplementations.Single());
+
+                    var c3M01Remove = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01.RemoveMethod);
+                    Assert.Equal("void C3.I1.remove_M01(System.Action value)", c3M01Remove.ToTestDisplayString());
+                    Assert.Same(m01.RemoveMethod, c3M01Remove.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Same(c2M01, c3.FindImplementationForInterfaceMember(m01));
+                    Assert.Same(c2M01Add, c3.FindImplementationForInterfaceMember(m01.AddMethod));
+                    Assert.Same(c2M01Remove, c3.FindImplementationForInterfaceMember(m01.RemoveMethod));
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticEvent_19(bool genericFirst)
+        {
+            // An "ambiguity" in implicit/explicit implementation declared in generic base class.
+
+            var generic =
+@"
+    public static event System.Action<T> M01 { add{} remove{} }
+";
+            var nonGeneric =
+@"
+    static event System.Action<int> I1.M01 { add{} remove{} }
+";
+            var source1 =
+@"
+public interface I1
+{
+    abstract static event System.Action<int> M01;
+}
+
+public class C1<T> : I1
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count());
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C1<int>, I1
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (EventSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("event System.Action<System.Int32> C1<T>.I1.M01", c1M01.OriginalDefinition.ToTestDisplayString());
+                Assert.Same(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c1M01, c2.BaseType().FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticEvent_20(bool genericFirst)
+        {
+            // Same as ImplementAbstractStaticEvent_19 only interface is generic too.
+
+            var generic =
+@"
+    static event System.Action<T> I1<T>.M01 { add{} remove{} }
+";
+            var nonGeneric =
+@"
+    public static event System.Action<int> M01 { add{} remove{} }
+";
+            var source1 =
+@"
+public interface I1<T>
+{
+    abstract static event System.Action<T> M01;
+}
+
+public class C1<T> : I1<T>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count());
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C2 : C1<int>, I1<int>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers().OfType<EventSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (EventSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("event System.Action<T> C1<T>.I1<T>.M01", c1M01.OriginalDefinition.ToTestDisplayString());
+                Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c1M01, c2.BaseType().FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        private static string ConversionOperatorName(string op) => op switch { "implicit" => WellKnownMemberNames.ImplicitConversionName, "explicit" => WellKnownMemberNames.ExplicitConversionName, _ => throw TestExceptionUtilities.UnexpectedValue(op) };
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_01([CombinatorialValues("implicit", "explicit")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            string opName = ConversionOperatorName(op);
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+" + typeKeyword + @"
+    C1 : I1<C1>
+{}
+
+" + typeKeyword + @"
+    C2 : I1<C2>
+{
+    public " + op + @" operator int(C2 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C3 : I1<C3>
+{
+    static " + op + @" operator int(C3 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C4 : I1<C4>
+{
+    " + op + @" I1<C4>.operator int(C4 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C5 : I1<C5>
+{
+    public static " + op + @" operator long(C5 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C6 : I1<C6>
+{
+    static " + op + @" I1<C6>.operator long(C6 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C7 : I1<C7>
+{
+    public static int " + opName + @"(C7 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C8 : I1<C8>
+{
+    static int I1<C8>." + opName + @"(C8 x) => throw null;
+}
+
+public interface I2<T> where T : I2<T>
+{
+    abstract static int " + opName + @"(T x);
+}
+
+" + typeKeyword + @"
+    C9 : I2<C9>
+{
+    public static " + op + @" operator int(C9 x) => throw null;
+}
+
+" + typeKeyword + @"
+    C10 : I2<C10>
+{
+    static " + op + @" I2<C10>.operator int(C10 x) => throw null;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (8,10): error CS0535: 'C1' does not implement interface member 'I1<C1>.explicit operator int(C1)'
+                //     C1 : I1<C1>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C1>").WithArguments("C1", "I1<C1>." + op + " operator int(C1)").WithLocation(8, 10),
+                // (12,10): error CS8928: 'C2' does not implement static interface member 'I1<C2>.explicit operator int(C2)'. 'C2.explicit operator int(C2)' cannot implement the interface member because it is not static.
+                //     C2 : I1<C2>
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotStatic, "I1<C2>").WithArguments("C2", "I1<C2>." + op + " operator int(C2)", "C2." + op + " operator int(C2)").WithLocation(12, 10),
+                // (14,30): error CS0558: User-defined operator 'C2.explicit operator int(C2)' must be declared static and public
+                //     public explicit operator int(C2 x) => throw null;
+                Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, "int").WithArguments("C2." + op + " operator int(C2)").WithLocation(14, 30),
+                // (18,10): error CS0737: 'C3' does not implement interface member 'I1<C3>.explicit operator int(C3)'. 'C3.explicit operator int(C3)' cannot implement an interface member because it is not public.
+                //     C3 : I1<C3>
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberNotPublic, "I1<C3>").WithArguments("C3", "I1<C3>." + op + " operator int(C3)", "C3." + op + " operator int(C3)").WithLocation(18, 10),
+                // (20,30): error CS0558: User-defined operator 'C3.explicit operator int(C3)' must be declared static and public
+                //     static explicit operator int(C3 x) => throw null;
+                Diagnostic(ErrorCode.ERR_OperatorsMustBeStatic, "int").WithArguments("C3." + op + " operator int(C3)").WithLocation(20, 30),
+                // (24,10): error CS0535: 'C4' does not implement interface member 'I1<C4>.explicit operator int(C4)'
+                //     C4 : I1<C4>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C4>").WithArguments("C4", "I1<C4>." + op + " operator int(C4)").WithLocation(24, 10),
+                // (26,30): error CS8930: Explicit implementation of a user-defined operator 'C4.explicit operator int(C4)' must be declared static
+                //     explicit I1<C4>.operator int(C4 x) => throw null;
+                Diagnostic(ErrorCode.ERR_ExplicitImplementationOfOperatorsMustBeStatic, "int").WithArguments("C4." + op + " operator int(C4)").WithLocation(26, 30),
+                // (26,30): error CS0539: 'C4.explicit operator int(C4)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     explicit I1<C4>.operator int(C4 x) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "int").WithArguments("C4." + op + " operator int(C4)").WithLocation(26, 30),
+                // (30,10): error CS0738: 'C5' does not implement interface member 'I1<C5>.explicit operator int(C5)'. 'C5.explicit operator long(C5)' cannot implement 'I1<C5>.explicit operator int(C5)' because it does not have the matching return type of 'int'.
+                //     C5 : I1<C5>
+                Diagnostic(ErrorCode.ERR_CloseUnimplementedInterfaceMemberWrongReturnType, "I1<C5>").WithArguments("C5", "I1<C5>." + op + " operator int(C5)", "C5." + op + " operator long(C5)", "int").WithLocation(30, 10),
+                // (36,10): error CS0535: 'C6' does not implement interface member 'I1<C6>.explicit operator int(C6)'
+                //     C6 : I1<C6>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C6>").WithArguments("C6", "I1<C6>." + op + " operator int(C6)").WithLocation(36, 10),
+                // (38,37): error CS0539: 'C6.explicit operator long(C6)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static explicit I1<C6>.operator long(C6 x) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "long").WithArguments("C6." + op + " operator long(C6)").WithLocation(38, 37),
+                // (42,10): error CS0535: 'C7' does not implement interface member 'I1<C7>.explicit operator int(C7)'
+                //     C7 : I1<C7>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C7>").WithArguments("C7", "I1<C7>." + op + " operator int(C7)").WithLocation(42, 10),
+                // (48,10): error CS0535: 'C8' does not implement interface member 'I1<C8>.explicit operator int(C8)'
+                //     C8 : I1<C8>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I1<C8>").WithArguments("C8", "I1<C8>." + op + " operator int(C8)").WithLocation(48, 10),
+                // (50,23): error CS0539: 'C8.op_Explicit(C8)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static int I1<C8>.op_Explicit(C8 x) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, opName).WithArguments("C8." + opName + "(C8)").WithLocation(50, 23),
+                // (59,10): error CS0535: 'C9' does not implement interface member 'I2<C9>.op_Explicit(C9)'
+                //     C9 : I2<C9>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2<C9>").WithArguments("C9", "I2<C9>." + opName + "(C9)").WithLocation(59, 10),
+                // (65,11): error CS0535: 'C10' does not implement interface member 'I2<C10>.op_Explicit(C10)'
+                //     C10 : I2<C10>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2<C10>").WithArguments("C10", "I2<C10>." + opName + "(C10)").WithLocation(65, 11),
+                // (67,38): error CS0539: 'C10.explicit operator int(C10)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static explicit I2<C10>.operator int(C10 x) => throw null;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "int").WithArguments("C10." + op + " operator int(C10)").WithLocation(67, 38)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_03([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+interface I2<T> : I1<T> where T : I1<T>
+{}
+
+interface I3<T> : I1<T> where T : I1<T>
+{
+    " + op + @" operator int(T x) => default;
+}
+
+interface I4<T> : I1<T> where T : I1<T>
+{
+    static " + op + @" operator int(T x) => default;
+}
+
+interface I5<T> : I1<T> where T : I1<T>
+{
+    " + op + @" I1<T>.operator int(T x) => default;
+}
+
+interface I6<T> : I1<T> where T : I1<T>
+{
+    static " + op + @" I1<T>.operator int(T x) => default;
+}
+
+interface I7<T> : I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+public interface I11<T> where T : I11<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+interface I8<T> : I11<T> where T : I8<T>
+{
+    " + op + @" operator int(T x) => default;
+}
+
+interface I9<T> : I11<T> where T : I9<T>
+{
+    static " + op + @" operator int(T x) => default;
+}
+
+interface I10<T> : I11<T> where T : I10<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+interface I12<T> : I11<T> where T : I12<T>
+{
+    static " + op + @" I11<T>.operator int(T x) => default;
+}
+
+interface I13<T> : I11<T> where T : I13<T>
+{
+    abstract static " + op + @" I11<T>.operator int(T x);
+}
+
+interface I14<T> : I1<T> where T : I1<T>
+{
+    abstract static " + op + @" I1<T>.operator int(T x);
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (12,23): error CS0556: User-defined conversion must convert to or from the enclosing type
+                //     implicit operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_ConversionNotInvolvingContainedType, "int").WithLocation(12, 23),
+                // (12,23): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     implicit operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "int").WithLocation(12, 23),
+                // (17,30): error CS0556: User-defined conversion must convert to or from the enclosing type
+                //     static implicit operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_ConversionNotInvolvingContainedType, "int").WithLocation(17, 30),
+                // (17,30): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     static implicit operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "int").WithLocation(17, 30),
+                // (22,29): error CS8930: Explicit implementation of a user-defined operator 'I5<T>.implicit operator int(T)' must be declared static
+                //     implicit I1<T>.operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_ExplicitImplementationOfOperatorsMustBeStatic, "int").WithArguments("I5<T>." + op + " operator int(T)").WithLocation(22, 29),
+                // (22,29): error CS0539: 'I5<T>.implicit operator int(T)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     implicit I1<T>.operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "int").WithArguments("I5<T>." + op + " operator int(T)").WithLocation(22, 29),
+                // (27,36): error CS0539: 'I6<T>.implicit operator int(T)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static implicit I1<T>.operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "int").WithArguments("I6<T>." + op + " operator int(T)").WithLocation(27, 36),
+                // (32,39): error CS8931: User-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
+                //     abstract static implicit operator int(T x);
+                Diagnostic(ErrorCode.ERR_AbstractConversionNotInvolvingContainedType, "int").WithLocation(32, 39),
+                // (42,23): error CS0556: User-defined conversion must convert to or from the enclosing type
+                //     implicit operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_ConversionNotInvolvingContainedType, "int").WithLocation(42, 23),
+                // (42,23): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     implicit operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "int").WithLocation(42, 23),
+                // (47,30): error CS0556: User-defined conversion must convert to or from the enclosing type
+                //     static implicit operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_ConversionNotInvolvingContainedType, "int").WithLocation(47, 30),
+                // (47,30): error CS0567: Conversion, equality, or inequality operators declared in interfaces must be abstract
+                //     static implicit operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainConversionOrEqualityOperators, "int").WithLocation(47, 30),
+                // (57,37): error CS0539: 'I12<T>.implicit operator int(T)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static implicit I11<T>.operator int(T x) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "int").WithArguments("I12<T>." + op + " operator int(T)").WithLocation(57, 37),
+                // (62,46): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static implicit I11<T>.operator int(T x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("abstract").WithLocation(62, 46),
+                // (62,46): error CS0501: 'I13<T>.implicit operator int(T)' must declare a body because it is not marked abstract, extern, or partial
+                //     abstract static implicit I11<T>.operator int(T x);
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "int").WithArguments("I13<T>." + op + " operator int(T)").WithLocation(62, 46),
+                // (62,46): error CS0539: 'I13<T>.implicit operator int(T)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     abstract static implicit I11<T>.operator int(T x);
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "int").WithArguments("I13<T>." + op + " operator int(T)").WithLocation(62, 46),
+                // (67,45): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static implicit I1<T>.operator int(T x);
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("abstract").WithLocation(67, 45),
+                // (67,45): error CS0501: 'I14<T>.implicit operator int(T)' must declare a body because it is not marked abstract, extern, or partial
+                //     abstract static implicit I1<T>.operator int(T x);
+                Diagnostic(ErrorCode.ERR_ConcreteMissingBody, "int").WithArguments("I14<T>." + op + " operator int(T)").WithLocation(67, 45),
+                // (67,45): error CS0539: 'I14<T>.implicit operator int(T)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     abstract static implicit I1<T>.operator int(T x);
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "int").WithArguments("I14<T>." + op + " operator int(T)").WithLocation(67, 45)
+                );
+
+            var m01 = compilation1.GlobalNamespace.GetTypeMember("I1").GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I2").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I3").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I4").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I5").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I6").FindImplementationForInterfaceMember(m01));
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I7").FindImplementationForInterfaceMember(m01));
+
+            var i8 = compilation1.GlobalNamespace.GetTypeMember("I8");
+            Assert.Null(i8.FindImplementationForInterfaceMember(i8.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i9 = compilation1.GlobalNamespace.GetTypeMember("I9");
+            Assert.Null(i9.FindImplementationForInterfaceMember(i9.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i10 = compilation1.GlobalNamespace.GetTypeMember("I10");
+            Assert.Null(i10.FindImplementationForInterfaceMember(i10.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i12 = compilation1.GlobalNamespace.GetTypeMember("I12");
+            Assert.Null(i12.FindImplementationForInterfaceMember(i12.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            var i13 = compilation1.GlobalNamespace.GetTypeMember("I13");
+            Assert.Null(i13.FindImplementationForInterfaceMember(i13.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single()));
+
+            Assert.Null(compilation1.GlobalNamespace.GetTypeMember("I14").FindImplementationForInterfaceMember(m01));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_04([CombinatorialValues("implicit", "explicit")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I2<T> where T : I2<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1 : I2<Test1>
+{
+    static " + op + @" I2<Test1>.operator int(Test1 x) => default;
+}
+" + typeKeyword + @"
+    Test2: I2<Test2>
+{
+    public static " + op + @" operator int(Test2 x) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,21): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //     static explicit I2<Test1>.operator int(Test1 x) => default;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I2<Test1>.").WithArguments("static abstract members in interfaces").WithLocation(4, 21)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (4,21): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //     static explicit I2<Test1>.operator int(Test1 x) => default;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I2<Test1>.").WithArguments("static abstract members in interfaces").WithLocation(4, 21),
+                // (14,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static explicit operator int(T x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "int").WithArguments("abstract", "9.0", "preview").WithLocation(14, 39)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_05([CombinatorialValues("implicit", "explicit")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T> 
+{
+    abstract static " + op + @" operator int(T x);
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1: I1<Test1>
+{
+    public static " + op + @" operator int(Test1 x) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (2,12): error CS8929: 'Test1.explicit operator int(Test1)' cannot implement interface member 'I1<Test1>.explicit operator int(Test1)' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1<Test1>
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1<Test1>").WithArguments("Test1." + op + " operator int(Test1)", "I1<Test1>." + op + " operator int(Test1)", "Test1").WithLocation(2, 12)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (2,12): error CS8929: 'Test1.explicit operator int(Test1)' cannot implement interface member 'I1<Test1>.explicit operator int(Test1)' in type 'Test1' because the target runtime doesn't support static abstract members in interfaces.
+                //     Test1: I1<Test1>
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfacesForMember, "I1<Test1>").WithArguments("Test1." + op + " operator int(Test1)", "I1<Test1>." + op + " operator int(Test1)", "Test1").WithLocation(2, 12),
+                // (9,39): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static explicit operator int(T x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "int").WithLocation(9, 39)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_06([CombinatorialValues("implicit", "explicit")] string op, bool structure)
+        {
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+";
+            var source2 =
+typeKeyword + @"
+    Test1 : I1<Test1>
+{
+    static " + op + @" I1<Test1>.operator int(Test1 x) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (4,40): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static explicit I1<Test1>.operator int(Test1 x) => default;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "int").WithLocation(4, 40)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (4,40): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     static explicit I1<Test1>.operator int(Test1 x) => default;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "int").WithLocation(4, 40),
+                // (9,39): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static explicit operator int(T x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "int").WithLocation(9, 39)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_07([CombinatorialValues("implicit", "explicit")] string op, bool structure)
+        {
+            // Basic implicit implementation scenario, MethodImpl is emitted
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+    abstract static " + op + @" operator long(T x);
+}
+
+" + typeKeyword + @"
+    C : I1<C>
+{
+    public static " + op + @" operator long(C x) => default;
+    public static " + op + @" operator int(C x) => default;
+}
+";
+
+            var opName = ConversionOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c = module.GlobalNamespace.GetTypeMember("C");
+                var i1 = c.Interfaces().Single();
+                Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var m01 = i1.GetMembers().OfType<MethodSymbol>().First();
+
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.Conversion, cM01.MethodKind);
+                Assert.False(cM01.HasRuntimeSpecialName);
+                Assert.True(cM01.HasSpecialName);
+
+                Assert.Equal("System.Int32 C." + opName + "(C x)", cM01.ToTestDisplayString());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(m01, cM01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(cM01.ExplicitInterfaceImplementations);
+                }
+
+                var m02 = i1.GetMembers().OfType<MethodSymbol>().ElementAt(1);
+
+                var cM02 = (MethodSymbol)c.FindImplementationForInterfaceMember(m02);
+
+                Assert.True(cM02.IsStatic);
+                Assert.False(cM02.IsAbstract);
+                Assert.False(cM02.IsVirtual);
+                Assert.False(cM02.IsMetadataVirtual());
+                Assert.False(cM02.IsMetadataFinal);
+                Assert.False(cM02.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.Conversion, cM02.MethodKind);
+                Assert.False(cM02.HasRuntimeSpecialName);
+                Assert.True(cM02.HasSpecialName);
+
+                Assert.Equal("System.Int64 C." + opName + "(C x)", cM02.ToTestDisplayString());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(m02, cM02.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(cM02.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_08([CombinatorialValues("implicit", "explicit")] string op, bool structure)
+        {
+            // Basic explicit implementation scenario
+
+            var typeKeyword = structure ? "struct" : "class";
+
+            var source1 =
+@"
+interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator C(T x);
+    abstract static " + op + @" operator int(T x);
+}
+
+" + typeKeyword + @"
+    C : I1<C>
+{
+    static " + op + @" I1<C>.operator int(C x) => int.MaxValue;
+    static " + op + @" I1<C>.operator C(C x) => default;
+}
+";
+
+            var opName = ConversionOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single();
+
+            Assert.Equal("default", node.ToString());
+            Assert.Equal("C", model.GetTypeInfo(node).ConvertedType.ToTestDisplayString());
+
+            var declaredSymbol = model.GetDeclaredSymbol(node.FirstAncestorOrSelf<ConversionOperatorDeclarationSyntax>());
+            Assert.Equal("C C.I1<C>." + opName + "(C x)", declaredSymbol.ToTestDisplayString());
+            Assert.DoesNotContain(opName, declaredSymbol.ContainingType.MemberNames);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped,
+                             emitOptions: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c = module.GlobalNamespace.GetTypeMember("C");
+                Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count());
+
+                var m01 = c.Interfaces().Single().GetMembers().OfType<MethodSymbol>().First();
+                var cM01 = (MethodSymbol)c.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(cM01.IsStatic);
+                Assert.False(cM01.IsAbstract);
+                Assert.False(cM01.IsVirtual);
+                Assert.False(cM01.IsMetadataVirtual());
+                Assert.False(cM01.IsMetadataFinal);
+                Assert.False(cM01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, cM01.MethodKind);
+                Assert.False(cM01.HasRuntimeSpecialName);
+                Assert.False(cM01.HasSpecialName);
+
+                Assert.Equal("C C.I1<C>." + opName + "(C x)", cM01.ToTestDisplayString());
+                Assert.Equal(m01, cM01.ExplicitInterfaceImplementations.Single());
+
+                var m02 = c.Interfaces().Single().GetMembers().OfType<MethodSymbol>().ElementAt(1);
+                var cM02 = (MethodSymbol)c.FindImplementationForInterfaceMember(m02);
+
+                Assert.True(cM02.IsStatic);
+                Assert.False(cM02.IsAbstract);
+                Assert.False(cM02.IsVirtual);
+                Assert.False(cM02.IsMetadataVirtual());
+                Assert.False(cM02.IsMetadataFinal);
+                Assert.False(cM02.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, cM02.MethodKind);
+                Assert.False(cM02.HasRuntimeSpecialName);
+                Assert.False(cM02.HasSpecialName);
+
+                Assert.Equal("System.Int32 C.I1<C>." + opName + "(C x)", cM02.ToTestDisplayString());
+                Assert.Equal(m02, cM02.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_09([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Explicit implementation from base is treated as an implementation
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+public class C2 : I1<C2>
+{
+    static " + op + @" I1<C2>.operator int(C2 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1<C2>
+{
+}
+";
+
+            var opName = ConversionOperatorName(op);
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                     parseOptions: parseOptions,
+                                                     targetFramework: TargetFramework.NetCoreApp,
+                                                     references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+                var m01 = c3.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                var cM01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+
+                Assert.Equal("System.Int32 C2.I1<C2>." + opName + "(C2 x)", cM01.ToTestDisplayString());
+                Assert.Equal(m01, cM01.ExplicitInterfaceImplementations.Single());
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_10([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Implicit implementation is considered only for types implementing interface in source.
+            // In metadata, only explicit implementations are considered
+
+            var opName = ConversionOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1`1<(class I1`1<!T>) T>
+{
+    // Methods
+    .method public hidebysig specialname abstract virtual static 
+        int32 " + opName + @" (
+            !T x
+        ) cil managed 
+    {
+    }
+}
+
+.class public auto ansi beforefieldinit C1
+    extends System.Object
+    implements class I1`1<class C1>
+{
+    .method private hidebysig static 
+        int32 'I1<C1>." + opName + @"' (
+            class C1 x
+        ) cil managed 
+    {
+        .override method int32 class I1`1<class C1>::" + opName + @"(!0)
+
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method public hidebysig static 
+        specialname int32 " + opName + @" (
+            class C1 x
+        ) cil managed 
+    {
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2053
+        // Code size 8 (0x8)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: nop
+        IL_0007: ret
+    }
+}
+
+.class public auto ansi beforefieldinit C2
+    extends C1
+    implements class I1`1<class C1>
+{
+    .method public hidebysig static 
+        specialname int32 " + opName + @" (
+            class C1 x
+        ) cil managed 
+    {
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void C1::.ctor()
+        IL_0006: ret
+    }
+}
+";
+            var source1 =
+@"
+public class C3 : C2
+{
+}
+
+public class C4 : C1, I1<C1>
+{
+}
+
+public class C5 : C2, I1<C1>
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal(MethodKind.Conversion, m01.MethodKind);
+            Assert.Equal(MethodKind.Conversion, c1.GetMember<MethodSymbol>(opName).MethodKind);
+
+            var c1M01 = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+            Assert.Equal("System.Int32 C1.I1<C1>." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+            Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01.MethodKind);
+            Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+
+            var c2 = compilation1.GlobalNamespace.GetTypeMember("C2");
+            Assert.Same(c1M01, c2.FindImplementationForInterfaceMember(m01));
+
+            var c3 = compilation1.GlobalNamespace.GetTypeMember("C3");
+            Assert.Same(c1M01, c3.FindImplementationForInterfaceMember(m01));
+
+            var c4 = compilation1.GlobalNamespace.GetTypeMember("C4");
+            Assert.Same(c1M01, c4.FindImplementationForInterfaceMember(m01));
+
+            var c5 = compilation1.GlobalNamespace.GetTypeMember("C5");
+
+            var c2M01 = (MethodSymbol)c5.FindImplementationForInterfaceMember(m01);
+            Assert.Equal("System.Int32 C2." + opName + "(C1 x)", c2M01.ToTestDisplayString());
+            Assert.Equal(MethodKind.Conversion, c2M01.MethodKind);
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_11([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Ignore invalid metadata (non-abstract static virtual method). 
+
+            var opName = ConversionOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1`1<(class I1`1<!T>) T>
+{
+    // Methods
+    .method public hidebysig specialname virtual static 
+        int32 " + opName + @" (
+            !T x
+        ) cil managed 
+    {
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+}
+";
+
+            var source1 =
+@"
+public class C1 : I1<C1>
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics();
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i1 = c1.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal(MethodKind.Conversion, m01.MethodKind);
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i1.FindImplementationForInterfaceMember(m01));
+
+            compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics();
+
+            var source2 =
+@"
+public class C1 : I1<C1>
+{
+    static " + op + @" I1<C1>.operator int(C1 x) => default;
+}
+";
+
+            var compilation2 = CreateCompilationWithIL(source2, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation2.VerifyEmitDiagnostics(
+                // (4,37): error CS0539: 'C1.implicit operator int(C1)' in explicit interface declaration is not found among members of the interface that can be implemented
+                //     static implicit I1<C1>.operator int(C1 x) => default;
+                Diagnostic(ErrorCode.ERR_InterfaceMemberNotFound, "int").WithArguments("C1." + op + " operator int(C1)").WithLocation(4, 37)
+                );
+
+            c1 = compilation2.GlobalNamespace.GetTypeMember("C1");
+            m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal("System.Int32 I1<C1>." + opName + "(C1 x)", m01.ToTestDisplayString());
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_12([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Ignore invalid metadata (default interface implementation for a static method)
+
+            var opName = ConversionOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1`1<(class I1`1<!T>) T>
+{
+    // Methods
+    .method public hidebysig specialname abstract virtual static 
+        int32 " + opName + @" (
+            !T x
+        ) cil managed 
+    {
+    }
+}
+
+.class interface public auto ansi abstract I2`1<(class I1`1<!T>) T>
+    implements class I1`1<!T>
+{
+    .method private hidebysig static 
+        int32 'I1<!T>." + opName + @"' (
+            !T x
+        ) cil managed 
+    {
+        .override method int32 class I1`1<!T>::" + opName + @"(!0)
+
+        IL_0000: ldc.i4.0
+        IL_0001: ret
+    }
+}
+";
+
+            var source1 =
+@"
+public class C1 : I2<C1>
+{
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyEmitDiagnostics(
+                // (2,19): error CS0535: 'C1' does not implement interface member 'I1<C1>.explicit operator int(C1)'
+                // public class C1 : I2<C1>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "I2<C1>").WithArguments("C1", "I1<C1>." + op + " operator int(C1)").WithLocation(2, 19)
+                );
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+            var i2 = c1.Interfaces().Single();
+            var i1 = i2.Interfaces().Single();
+            var m01 = i1.GetMembers().OfType<MethodSymbol>().Single();
+
+            Assert.Equal(MethodKind.Conversion, m01.MethodKind);
+            Assert.Null(c1.FindImplementationForInterfaceMember(m01));
+            Assert.Null(i2.FindImplementationForInterfaceMember(m01));
+
+            var i2M01 = i2.GetMembers().OfType<MethodSymbol>().Single();
+            Assert.Equal(m01, i2M01.ExplicitInterfaceImplementations.Single());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_13([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // A forwarding method is added for an implicit implementation declared in base class. 
+
+            var source1 =
+@"
+public partial interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator C1<T>(T x);
+}
+
+public partial class C1<T>
+{
+    public static " + op + @" operator C1<T>(T x) => default;
+}
+
+public class C2 : C1<C2>, I1<C2>
+{
+}
+";
+
+            var opName = ConversionOperatorName(op);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var i1 = c2.Interfaces().Single();
+                var m01 = i1.GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                var c2M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01.MethodKind);
+                    Assert.False(c2M01.HasRuntimeSpecialName);
+                    Assert.False(c2M01.HasSpecialName);
+
+                    Assert.Equal("C1<C2> C2.I1<C2>." + opName + "(C2 x)", c2M01.ToTestDisplayString());
+                    Assert.Equal(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                    var c1M01 = module.GlobalNamespace.GetMember<MethodSymbol>("C1." + opName);
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.False(c1M01.IsMetadataVirtual());
+                    Assert.False(c1M01.IsMetadataFinal);
+                    Assert.False(c1M01.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.Conversion, c1M01.MethodKind);
+                    Assert.False(c1M01.HasRuntimeSpecialName);
+                    Assert.True(c1M01.HasSpecialName);
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.Equal(MethodKind.Conversion, c2M01.MethodKind);
+                    Assert.False(c2M01.HasRuntimeSpecialName);
+                    Assert.True(c2M01.HasSpecialName);
+
+                    Assert.Equal("C1<C2> C1<C2>." + opName + "(C2 x)", c2M01.ToTestDisplayString());
+                    Assert.Empty(c2M01.ExplicitInterfaceImplementations);
+                }
+            }
+
+            verifier.VerifyIL("C2.I1<C2>." + opName + "(C2)",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""C1<C2> C1<C2>." + opName + @"(C2)""
+  IL_0006:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_14([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // A forwarding method is added for an implicit implementation with modopt mismatch. 
+
+            var opName = ConversionOperatorName(op);
+
+            var ilSource = @"
+.class interface public auto ansi abstract I1`1<(class I1`1<!T>) T>
+{
+    // Methods
+    .method public hidebysig specialname abstract virtual static 
+        int32 modopt(I1`1) " + opName + @" (
+            !T x
+        ) cil managed 
+    {
+    }
+} 
+";
+
+            var source1 =
+@"
+class C1 : I1<C1>
+{
+    public static " + op + @" operator int(C1 x) => default;
+}
+
+class C2 : I1<C2>
+{
+    static " + op + @" I1<C2>.operator int(C2 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var c1 = module.GlobalNamespace.GetTypeMember("C1");
+                var m01 = c1.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+
+                var c1M01 = (MethodSymbol)c1.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+                Assert.False(c1M01.IsMetadataVirtual());
+                Assert.False(c1M01.IsMetadataFinal);
+                Assert.False(c1M01.IsMetadataNewSlot());
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c1M01.MethodKind);
+                    Assert.Equal("System.Int32 modopt(I1<>) C1.I1<C1>." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+                    Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+
+                    c1M01 = module.GlobalNamespace.GetMember<MethodSymbol>("C1." + opName);
+                    Assert.Equal("System.Int32 C1." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+
+                    Assert.True(c1M01.IsStatic);
+                    Assert.False(c1M01.IsAbstract);
+                    Assert.False(c1M01.IsVirtual);
+                    Assert.False(c1M01.IsMetadataVirtual());
+                    Assert.False(c1M01.IsMetadataFinal);
+                    Assert.False(c1M01.IsMetadataNewSlot());
+                    Assert.Equal(MethodKind.Conversion, c1M01.MethodKind);
+
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+                else
+                {
+                    Assert.Equal(MethodKind.Conversion, c1M01.MethodKind);
+                    Assert.Equal("System.Int32 C1." + opName + "(C1 x)", c1M01.ToTestDisplayString());
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                m01 = c2.Interfaces().Single().GetMembers().OfType<MethodSymbol>().Single();
+                var c2M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+
+                Assert.True(c2M01.IsStatic);
+                Assert.False(c2M01.IsAbstract);
+                Assert.False(c2M01.IsVirtual);
+                Assert.False(c2M01.IsMetadataVirtual());
+                Assert.False(c2M01.IsMetadataFinal);
+                Assert.False(c2M01.IsMetadataNewSlot());
+                Assert.Equal(MethodKind.ExplicitInterfaceImplementation, c2M01.MethodKind);
+
+                Assert.Equal("System.Int32 modopt(I1<>) C2.I1<C2>." + opName + "(C2 x)", c2M01.ToTestDisplayString());
+                Assert.Equal(m01, c2M01.ExplicitInterfaceImplementations.Single());
+
+                Assert.Same(c2M01, c2.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Single());
+            }
+
+            verifier.VerifyIL("C1.I1<C1>." + opName + "(C1)",
+@"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""int C1." + opName + @"(C1)""
+  IL_0006:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_15([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // A forwarding method isn't created if base class implements interface exactly the same way. 
+
+            var source1 =
+@"
+public partial interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator C1<T>(T x);
+    abstract static " + op + @" operator T(int x);
+}
+
+public partial class C1<T>
+{
+    public static " + op + @" operator C1<T>(T x) => default;
+}
+
+public class C2 : C1<C2>, I1<C2>
+{
+    static " + op + @" I1<C2>.operator C2(int x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics();
+
+            var source2 =
+@"
+public class C3 : C2, I1<C2>
+{
+}
+";
+
+            var opName = ConversionOperatorName(op);
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.RegularPreview, TestOptions.Regular9 })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                         parseOptions: parseOptions,
+                                                         targetFramework: TargetFramework.NetCoreApp,
+                                                         references: new[] { reference });
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c3 = module.GlobalNamespace.GetTypeMember("C3");
+                Assert.Empty(c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()));
+
+                var m01 = c3.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().First();
+
+                var c1M01 = c3.BaseType().BaseType().GetMember<MethodSymbol>(opName);
+                Assert.Equal("C1<C2> C1<C2>." + opName + "(C2 x)", c1M01.ToTestDisplayString());
+
+                Assert.True(c1M01.IsStatic);
+                Assert.False(c1M01.IsAbstract);
+                Assert.False(c1M01.IsVirtual);
+                Assert.False(c1M01.IsMetadataVirtual());
+                Assert.False(c1M01.IsMetadataFinal);
+                Assert.False(c1M01.IsMetadataNewSlot());
+
+                Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+
+                if (c1M01.ContainingModule is PEModuleSymbol)
+                {
+                    var c2M01 = (MethodSymbol)c3.FindImplementationForInterfaceMember(m01);
+                    Assert.Equal("C1<C2> C2.I1<C2>." + opName + "(C2 x)", c2M01.ToTestDisplayString());
+                    Assert.Equal(m01, c2M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Equal(c1M01, c3.FindImplementationForInterfaceMember(m01));
+                }
+
+                var m02 = c3.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().ElementAt(1);
+
+                var c2M02 = c3.BaseType().GetMembers("I1<C2>." + opName).OfType<MethodSymbol>().First();
+                Assert.Equal("C2 C2.I1<C2>." + opName + "(System.Int32 x)", c2M02.ToTestDisplayString());
+                Assert.Same(c2M02, c3.FindImplementationForInterfaceMember(m02));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_18([CombinatorialValues("implicit", "explicit")] string op, bool genericFirst)
+        {
+            // An "ambiguity" in implicit implementation declared in generic base class plus interface is generic too.
+
+            var generic =
+@"
+    public static " + op + @" operator U(C1<T, U> x) => default;
+";
+            var nonGeneric =
+@"
+    public static " + op + @" operator int(C1<T, U> x) => default;
+";
+            var source1 =
+@"
+public interface I1<T, U> where T : I1<T, U>
+{
+    abstract static " + op + @" operator U(T x);
+}
+
+public class C1<T, U> : I1<C1<T, U>, U>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+
+
+            var opName = ConversionOperatorName(op);
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            compilation1.VerifyDiagnostics();
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count());
+
+            var source2 =
+@"
+public class C2 : C1<int, int>, I1<C1<int, int>, int>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("U C1<T, U>." + opName + "(C1<T, U> x)", c1M01.OriginalDefinition.ToTestDisplayString());
+
+                var baseI1M01 = c2.BaseType().FindImplementationForInterfaceMember(m01);
+                Assert.Equal("U C1<T, U>." + opName + "(C1<T, U> x)", baseI1M01.OriginalDefinition.ToTestDisplayString());
+
+                Assert.Equal(c1M01, baseI1M01);
+
+                if (c1M01.OriginalDefinition.ContainingModule is PEModuleSymbol)
+                {
+                    Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                }
+                else
+                {
+                    Assert.Empty(c1M01.ExplicitInterfaceImplementations);
+                }
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ImplementAbstractStaticConversionOperator_20([CombinatorialValues("implicit", "explicit")] string op, bool genericFirst)
+        {
+            // Same as ImplementAbstractStaticConversionOperator_18 only implementation is explicit in source.
+
+            var generic =
+@"
+    static " + op + @" I1<C1<T, U>, U>.operator U(C1<T, U> x) => default;
+";
+            var nonGeneric =
+@"
+    public static " + op + @" operator int(C1<T, U> x) => default;
+";
+            var source1 =
+@"
+public interface I1<T, U> where T : I1<T, U>
+{
+    abstract static " + op + @" operator U(T x);
+}
+
+public class C1<T, U> : I1<C1<T, U>, U>
+{
+" + (genericFirst ? generic + nonGeneric : nonGeneric + generic) + @"
+}
+";
+            var opName = ConversionOperatorName(op);
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateCompilation("", targetFramework: TargetFramework.NetCoreApp).ToMetadataReference() });
+
+            compilation1.VerifyDiagnostics();
+            Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count());
+
+            var source2 =
+@"
+public class C2 : C1<int, int>, I1<C1<int, int>, int>
+{
+}
+";
+
+            foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
+            {
+                foreach (var parseOptions in new[] { TestOptions.Regular9, TestOptions.RegularPreview })
+                {
+                    var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: parseOptions,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { reference });
+
+                    CompileAndVerify(compilation2, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+                }
+            }
+
+            void validate(ModuleSymbol module)
+            {
+                var c2 = module.GlobalNamespace.GetTypeMember("C2");
+                var m01 = c2.Interfaces().Single().GetMembers(opName).OfType<MethodSymbol>().Single();
+
+                Assert.True(m01.ContainingModule is RetargetingModuleSymbol or PEModuleSymbol);
+
+                var c1M01 = (MethodSymbol)c2.FindImplementationForInterfaceMember(m01);
+                Assert.Equal("U C1<T, U>.I1<C1<T, U>, U>." + opName + "(C1<T, U> x)", c1M01.OriginalDefinition.ToTestDisplayString());
+
+                Assert.Equal(m01, c1M01.ExplicitInterfaceImplementations.Single());
+                Assert.Same(c1M01, c2.BaseType().FindImplementationForInterfaceMember(m01));
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ExplicitImplementationModifiersConversionOperator_01([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+class
+    C1 : I1<C1>
+{
+    static " + op + @" I1<C1>.operator int(C1 x) => default;
+}
+
+class
+    C2 : I1<C2>
+{
+    private static " + op + @" I1<C2>.operator int(C2 x) => default;
+}
+
+class
+    C3 : I1<C3>
+{
+    protected static " + op + @" I1<C3>.operator int(C3 x) => default;
+}
+
+class
+    C4 : I1<C4>
+{
+    internal static " + op + @" I1<C4>.operator int(C4 x) => default;
+}
+
+class
+    C5 : I1<C5>
+{
+    protected internal static " + op + @" I1<C5>.operator int(C5 x) => default;
+}
+
+class
+    C6 : I1<C6>
+{
+    private protected static " + op + @" I1<C6>.operator int(C6 x) => default;
+}
+
+class
+    C7 : I1<C7>
+{
+    public static " + op + @" I1<C7>.operator int(C7 x) => default;
+}
+
+class
+    C9 : I1<C9>
+{
+    async static " + op + @" I1<C9>.operator int(C9 x) => default;
+}
+
+class
+    C10 : I1<C10>
+{
+    unsafe static " + op + @" I1<C10>.operator int(C10 x) => default;
+}
+
+class
+    C11 : I1<C11>
+{
+    static readonly " + op + @" I1<C11>.operator int(C11 x) => default;
+}
+
+class
+    C12 : I1<C12>
+{
+    extern static " + op + @" I1<C12>.operator int(C12 x);
+}
+
+class
+    C13 : I1<C13>
+{
+    abstract static " + op + @" I1<C13>.operator int(C13 x) => default;
+}
+
+class
+    C14 : I1<C14>
+{
+    virtual static " + op + @" I1<C14>.operator int(C14 x) => default;
+}
+
+class
+    C15 : I1<C15>
+{
+    sealed static " + op + @" I1<C15>.operator int(C15 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll.WithAllowUnsafe(true),
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var c1 = compilation1.GlobalNamespace.GetTypeMember("C1");
+
+            Assert.Equal(Accessibility.Private, c1.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Single().DeclaredAccessibility);
+
+            compilation1.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.WRN_ExternMethodNoImplementation).Verify(
+                // (16,45): error CS0106: The modifier 'private' is not valid for this item
+                //     private static explicit I1<C2>.operator int(C2 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("private").WithLocation(16, 45),
+                // (22,47): error CS0106: The modifier 'protected' is not valid for this item
+                //     protected static explicit I1<C3>.operator int(C3 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("protected").WithLocation(22, 47),
+                // (28,46): error CS0106: The modifier 'internal' is not valid for this item
+                //     internal static explicit I1<C4>.operator int(C4 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("internal").WithLocation(28, 46),
+                // (34,56): error CS0106: The modifier 'protected internal' is not valid for this item
+                //     protected internal static explicit I1<C5>.operator int(C5 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("protected internal").WithLocation(34, 56),
+                // (40,55): error CS0106: The modifier 'private protected' is not valid for this item
+                //     private protected static explicit I1<C6>.operator int(C6 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("private protected").WithLocation(40, 55),
+                // (46,44): error CS0106: The modifier 'public' is not valid for this item
+                //     public static explicit I1<C7>.operator int(C7 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("public").WithLocation(46, 44),
+                // (52,43): error CS0106: The modifier 'async' is not valid for this item
+                //     async static explicit I1<C9>.operator int(C9 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("async").WithLocation(52, 43),
+                // (64,47): error CS0106: The modifier 'readonly' is not valid for this item
+                //     static readonly explicit I1<C11>.operator int(C11 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("readonly").WithLocation(64, 47),
+                // (76,47): error CS0106: The modifier 'abstract' is not valid for this item
+                //     abstract static explicit I1<C13>.operator int(C13 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("abstract").WithLocation(76, 47),
+                // (82,46): error CS0106: The modifier 'virtual' is not valid for this item
+                //     virtual static explicit I1<C14>.operator int(C14 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("virtual").WithLocation(82, 46),
+                // (88,45): error CS0106: The modifier 'sealed' is not valid for this item
+                //     sealed static explicit I1<C15>.operator int(C15 x) => default;
+                Diagnostic(ErrorCode.ERR_BadMemberFlag, "int").WithArguments("sealed").WithLocation(88, 45)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ExplicitInterfaceSpecifierErrorsConversionOperator_01([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : struct, I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+class C1
+{
+    static " + op + @" I1<int>.operator int(int x) => default;
+}
+
+class C2 : I1<C2>
+{
+    static " + op + @" I1<C2>.operator int(C2 x) => default;
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (9,21): error CS0540: 'C1.I1<int>.implicit operator int(int)': containing type does not implement interface 'I1<int>'
+                //     static implicit I1<int>.operator int(int x) => default;
+                Diagnostic(ErrorCode.ERR_ClassDoesntImplementInterface, "I1<int>").WithArguments("C1.I1<int>." + op + " operator int(int)", "I1<int>").WithLocation(9, 21),
+                // (9,21): error CS0315: The type 'int' cannot be used as type parameter 'T' in the generic type or method 'I1<T>'. There is no boxing conversion from 'int' to 'I1<int>'.
+                //     static implicit I1<int>.operator int(int x) => default;
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedValType, "I1<int>").WithArguments("I1<T>", "I1<int>", "T", "int").WithLocation(9, 21),
+                // (12,7): error CS0453: The type 'C2' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                // class C2 : I1<C2>
+                Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, "C2").WithArguments("I1<T>", "T", "C2").WithLocation(12, 7),
+                // (14,21): error CS0453: The type 'C2' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'I1<T>'
+                //     static implicit I1<C2>.operator int(C2 x) => default;
+                Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, "I1<C2>").WithArguments("I1<T>", "T", "C2").WithLocation(14, 21)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_01([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            string cast = (op == "explicit" ? "(int)" : "");
+
+            var source1 =
+@"
+interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+
+    static int M02(I1<T> x)
+    {
+        return " + cast + @"x;
+    }
+
+    int M03(I1<T> y)
+    {
+        return " + cast + @"y;
+    }
+}
+
+class Test<T> where T : I1<T>
+{
+    static int MT1(I1<T> a)
+    {
+        return " + cast + @"a;
+    }
+
+    static void MT2()
+    {
+        _ = (System.Linq.Expressions.Expression<System.Func<T, int>>)((T b) => " + cast + @"b);
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var error = (op == "explicit" ? ErrorCode.ERR_NoExplicitConv : ErrorCode.ERR_NoImplicitConv);
+
+            compilation1.VerifyDiagnostics(
+                // (8,16): error CS0030: Cannot convert type 'I1<T>' to 'int'
+                //         return (int)x;
+                Diagnostic(error, cast + "x").WithArguments("I1<T>", "int").WithLocation(8, 16),
+                // (13,16): error CS0030: Cannot convert type 'I1<T>' to 'int'
+                //         return (int)y;
+                Diagnostic(error, cast + "y").WithArguments("I1<T>", "int").WithLocation(13, 16),
+                // (21,16): error CS0030: Cannot convert type 'I1<T>' to 'int'
+                //         return (int)a;
+                Diagnostic(error, cast + "a").WithArguments("I1<T>", "int").WithLocation(21, 16),
+                // (26,80): error CS8927: An expression tree may not contain an access of static abstract interface member
+                //         _ = (System.Linq.Expressions.Expression<System.Func<T, int>>)((T b) => (int)b);
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAbstractStaticMemberAccess, cast + "b").WithLocation(26, 80)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperatorForTupleEquality_01([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+interface I1
+{
+    abstract static implicit operator bool(I1 x);
+
+
+    static void M02((int, C<I1>) x)
+    {
+        _ = x " + op + @" x;
+    }
+
+    void M03((int, C<I1>) y)
+    {
+        _ = y " + op + @" y;
+    }
+}
+
+class Test
+{
+    static void MT1((int, C<I1>) a)
+    {
+        _ = a " + op + @" a;
+    }
+
+    static void MT2<T>() where T : I1
+    {
+        _ = (System.Linq.Expressions.Expression<System.Action<(int, C<T>)>>)(((int, C<T>) b) => (b " + op + @" b).ToString());
+    }
+}
+
+#pragma warning disable CS0660 // 'C<T>' defines operator == or operator != but does not override Object.Equals(object o)
+#pragma warning disable CS0661 // 'C<T>' defines operator == or operator != but does not override Object.GetHashCode()
+
+class C<T>
+{
+    public static T operator == (C<T> x, C<T> y) => default;
+    public static T operator != (C<T> x, C<T> y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation1.VerifyDiagnostics(
+                // (4,39): error CS0552: 'I1.implicit operator bool(I1)': user-defined conversions to or from an interface are not allowed
+                //     abstract static implicit operator bool(I1 x);
+                Diagnostic(ErrorCode.ERR_ConversionWithInterface, "bool").WithArguments("I1.implicit operator bool(I1)").WithLocation(4, 39),
+                // (9,13): error CS0029: Cannot implicitly convert type 'I1' to 'bool'
+                //         _ = x == x;
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "x " + op + " x").WithArguments("I1", "bool").WithLocation(9, 13),
+                // (14,13): error CS0029: Cannot implicitly convert type 'I1' to 'bool'
+                //         _ = y == y;
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "y " + op + " y").WithArguments("I1", "bool").WithLocation(14, 13),
+                // (22,13): error CS0029: Cannot implicitly convert type 'I1' to 'bool'
+                //         _ = a == a;
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "a " + op + " a").WithArguments("I1", "bool").WithLocation(22, 13),
+                // (27,98): error CS8382: An expression tree may not contain a tuple == or != operator
+                //         _ = (System.Linq.Expressions.Expression<System.Action<(int, C<T>)>>)(((int, C<T>) b) => (b == b).ToString());
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsTupleBinOp, "b " + op + " b").WithLocation(27, 98)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_03([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            string metadataName = ConversionOperatorName(op);
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+class Test
+{
+    static int M02<T, U>(T x) where T : U where U : I1<T>
+    {
+        return " + (needCast ? "(int)" : "") + @"x;
+    }
+
+    static int? M03<T, U>(T y) where T : U where U : I1<T>
+    {
+        return " + (needCast ? "(int?)" : "") + @"y;
+    }
+
+    static int? M04<T, U>(T? y) where T : struct, U where U : I1<T>
+    {
+        return " + (needCast ? "(int?)" : "") + @"y;
+    }
+
+    static int? M05<T, U>() where T : struct, U where U : I1<T>
+    {
+        return " + (needCast ? "(int?)" : "") + @"(T?)new T();
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  .locals init (int V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""int I1<T>." + metadataName + @"(T)""
+  IL_000d:  stloc.0
+  IL_000e:  br.s       IL_0010
+  IL_0010:  ldloc.0
+  IL_0011:  ret
+}
+");
+            verifier.VerifyIL("Test.M03<T, U>(T)",
+@"
+{
+  // Code size       23 (0x17)
+  .maxstack  1
+  .locals init (int? V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""int I1<T>." + metadataName + @"(T)""
+  IL_000d:  newobj     ""int?..ctor(int)""
+  IL_0012:  stloc.0
+  IL_0013:  br.s       IL_0015
+  IL_0015:  ldloc.0
+  IL_0016:  ret
+}
+");
+            verifier.VerifyIL("Test.M04<T, U>(T?)",
+@"
+{
+  // Code size       51 (0x33)
+  .maxstack  1
+  .locals init (T? V_0,
+                int? V_1,
+                int? V_2)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloca.s   V_0
+  IL_0005:  call       ""readonly bool T?.HasValue.get""
+  IL_000a:  brtrue.s   IL_0017
+  IL_000c:  ldloca.s   V_1
+  IL_000e:  initobj    ""int?""
+  IL_0014:  ldloc.1
+  IL_0015:  br.s       IL_002e
+  IL_0017:  ldloca.s   V_0
+  IL_0019:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001e:  constrained. ""T""
+  IL_0024:  call       ""int I1<T>." + metadataName + @"(T)""
+  IL_0029:  newobj     ""int?..ctor(int)""
+  IL_002e:  stloc.2
+  IL_002f:  br.s       IL_0031
+  IL_0031:  ldloc.2
+  IL_0032:  ret
+}
+");
+            verifier.VerifyIL("Test.M05<T, U>()",
+@"
+{
+  // Code size       27 (0x1b)
+  .maxstack  1
+  .locals init (int? V_0)
+  IL_0000:  nop
+  IL_0001:  call       ""T System.Activator.CreateInstance<T>()""
+  IL_0006:  constrained. ""T""
+  IL_000c:  call       ""int I1<T>." + metadataName + @"(T)""
+  IL_0011:  newobj     ""int?..ctor(int)""
+  IL_0016:  stloc.0
+  IL_0017:  br.s       IL_0019
+  IL_0019:  ldloc.0
+  IL_001a:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       13 (0xd)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""int I1<T>." + metadataName + @"(T)""
+  IL_000c:  ret
+}
+");
+            verifier.VerifyIL("Test.M03<T, U>(T)",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""int I1<T>." + metadataName + @"(T)""
+  IL_000c:  newobj     ""int?..ctor(int)""
+  IL_0011:  ret
+}
+");
+            verifier.VerifyIL("Test.M04<T, U>(T?)",
+@"
+{
+  // Code size       45 (0x2d)
+  .maxstack  1
+  .locals init (T? V_0,
+                int? V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloca.s   V_0
+  IL_0004:  call       ""readonly bool T?.HasValue.get""
+  IL_0009:  brtrue.s   IL_0015
+  IL_000b:  ldloca.s   V_1
+  IL_000d:  initobj    ""int?""
+  IL_0013:  ldloc.1
+  IL_0014:  ret
+  IL_0015:  ldloca.s   V_0
+  IL_0017:  call       ""readonly T T?.GetValueOrDefault()""
+  IL_001c:  constrained. ""T""
+  IL_0022:  call       ""int I1<T>." + metadataName + @"(T)""
+  IL_0027:  newobj     ""int?..ctor(int)""
+  IL_002c:  ret
+}
+");
+            verifier.VerifyIL("Test.M05<T, U>()",
+@"
+{
+  // Code size       22 (0x16)
+  .maxstack  1
+  IL_0000:  call       ""T System.Activator.CreateInstance<T>()""
+  IL_0005:  constrained. ""T""
+  IL_000b:  call       ""int I1<T>." + metadataName + @"(T)""
+  IL_0010:  newobj     ""int?..ctor(int)""
+  IL_0015:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().First();
+
+            Assert.Equal("return " + (needCast ? "(int)" : "") + @"x;", node.ToString());
+
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                                reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                                to expose this information? 
+@"
+IReturnOperation (OperationKind.Return, Type: null) (Syntax: 'return " + (needCast ? "(int)" : "") + @"x;')
+  ReturnedValue: 
+    IConversionOperation (TryCast: False, Unchecked) (OperatorMethod: System.Int32 I1<T>." + metadataName + @"(T x)) (OperationKind.Conversion, Type: System.Int32" + (needCast ? "" : ", IsImplicit") + @") (Syntax: '" + (needCast ? "(int)" : "") + @"x')
+      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: True) (MethodSymbol: System.Int32 I1<T>." + metadataName + @"(T x))
+      Operand: 
+        IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: T) (Syntax: 'x')
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperatorForTupleEquality_03([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static implicit operator bool (T x);
+}
+
+class Test
+{
+    static void M02<T, U>((int, C<T>) x) where T : U where U : I1<T>
+    {
+        _ = x " + op + @" x;
+    }
+}
+
+#pragma warning disable CS0660 // 'C<T>' defines operator == or operator != but does not override Object.Equals(object o)
+#pragma warning disable CS0661 // 'C<T>' defines operator == or operator != but does not override Object.GetHashCode()
+
+class C<T>
+{
+    public static T operator == (C<T> x, C<T> y) => default;
+    public static T operator != (C<T> x, C<T> y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            if (op == "==")
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, C<T>>)",
+@"
+{
+  // Code size       52 (0x34)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, C<T>> V_0,
+                System.ValueTuple<int, C<T>> V_1)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldarg.0
+  IL_0004:  stloc.1
+  IL_0005:  ldloc.0
+  IL_0006:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_000b:  ldloc.1
+  IL_000c:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_0011:  bne.un.s   IL_0031
+  IL_0013:  ldloc.0
+  IL_0014:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_0019:  ldloc.1
+  IL_001a:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_001f:  call       ""T C<T>.op_Equality(C<T>, C<T>)""
+  IL_0024:  constrained. ""T""
+  IL_002a:  call       ""bool I1<T>.op_Implicit(T)""
+  IL_002f:  br.s       IL_0032
+  IL_0031:  ldc.i4.0
+  IL_0032:  pop
+  IL_0033:  ret
+}
+");
+            }
+            else
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, C<T>>)",
+@"
+{
+  // Code size       52 (0x34)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, C<T>> V_0,
+                System.ValueTuple<int, C<T>> V_1)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldarg.0
+  IL_0004:  stloc.1
+  IL_0005:  ldloc.0
+  IL_0006:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_000b:  ldloc.1
+  IL_000c:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_0011:  bne.un.s   IL_0031
+  IL_0013:  ldloc.0
+  IL_0014:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_0019:  ldloc.1
+  IL_001a:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_001f:  call       ""T C<T>.op_Inequality(C<T>, C<T>)""
+  IL_0024:  constrained. ""T""
+  IL_002a:  call       ""bool I1<T>.op_Implicit(T)""
+  IL_002f:  br.s       IL_0032
+  IL_0031:  ldc.i4.1
+  IL_0032:  pop
+  IL_0033:  ret
+}
+");
+            }
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+
+            if (op == "==")
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, C<T>>)",
+@"
+{
+  // Code size       51 (0x33)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, C<T>> V_0,
+                System.ValueTuple<int, C<T>> V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldarg.0
+  IL_0003:  stloc.1
+  IL_0004:  ldloc.0
+  IL_0005:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_000a:  ldloc.1
+  IL_000b:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_0010:  bne.un.s   IL_0030
+  IL_0012:  ldloc.0
+  IL_0013:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_0018:  ldloc.1
+  IL_0019:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_001e:  call       ""T C<T>.op_Equality(C<T>, C<T>)""
+  IL_0023:  constrained. ""T""
+  IL_0029:  call       ""bool I1<T>.op_Implicit(T)""
+  IL_002e:  br.s       IL_0031
+  IL_0030:  ldc.i4.0
+  IL_0031:  pop
+  IL_0032:  ret
+}
+");
+            }
+            else
+            {
+                verifier.VerifyIL("Test.M02<T, U>(System.ValueTuple<int, C<T>>)",
+@"
+{
+  // Code size       51 (0x33)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, C<T>> V_0,
+                System.ValueTuple<int, C<T>> V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldarg.0
+  IL_0003:  stloc.1
+  IL_0004:  ldloc.0
+  IL_0005:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_000a:  ldloc.1
+  IL_000b:  ldfld      ""int System.ValueTuple<int, C<T>>.Item1""
+  IL_0010:  bne.un.s   IL_0030
+  IL_0012:  ldloc.0
+  IL_0013:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_0018:  ldloc.1
+  IL_0019:  ldfld      ""C<T> System.ValueTuple<int, C<T>>.Item2""
+  IL_001e:  call       ""T C<T>.op_Inequality(C<T>, C<T>)""
+  IL_0023:  constrained. ""T""
+  IL_0029:  call       ""bool I1<T>.op_Implicit(T)""
+  IL_002e:  br.s       IL_0031
+  IL_0030:  ldc.i4.1
+  IL_0031:  pop
+  IL_0032:  ret
+}
+");
+            }
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().First();
+
+            Assert.Equal("x " + op + " x", node.ToString());
+            VerifyOperationTreeForNode(compilation1, model, node,
+// Information about user-defined operators isn't exposed today.
+@"
+ITupleBinaryOperation (BinaryOperatorKind." + (op == "==" ? "Equals" : "NotEquals") + @") (OperationKind.TupleBinary, Type: System.Boolean) (Syntax: 'x " + op + @" x')
+  Left: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: (System.Int32, C<T>)) (Syntax: 'x')
+  Right: 
+    IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: (System.Int32, C<T>)) (Syntax: 'x')
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_04([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static int M02<T>(T x) where T : I1<T>
+    {
+        return " + (needCast ? "(int)" : "") + @"x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,16): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         return (int)x;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, (needCast ? "(int)" : "") + "x").WithLocation(6, 16)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_OperatorNeedsMatch).Verify(
+                // (12,39): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static explicit operator int(T x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "int").WithLocation(12, 39)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperatorForTupleEquality_04([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static implicit operator bool(T x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>((int, C<T>) x) where T : I1<T>
+    {
+        _ = x " + op + @" x;
+    }
+}
+
+#pragma warning disable CS0660 // 'C<T>' defines operator == or operator != but does not override Object.Equals(object o)
+#pragma warning disable CS0661 // 'C<T>' defines operator == or operator != but does not override Object.GetHashCode()
+
+class C<T>
+{
+    public static T operator == (C<T> x, C<T> y) => default;
+    public static T operator != (C<T> x, C<T> y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //         _ = x == x;
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "x " + op + " x").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.DesktopLatestExtended);
+
+            compilation3.VerifyDiagnostics(
+                // (21,39): error CS8919: Target runtime doesn't support static abstract members in interfaces.
+                //     abstract static implicit operator bool(T x);
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, "bool").WithLocation(21, 39)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_06([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static int M02<T>(T x) where T : I1<T>
+    {
+        return " + (needCast ? "(int)" : "") + @"x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,16): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         return x;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, (needCast ? "(int)" : "") + "x").WithArguments("static abstract members in interfaces").WithLocation(6, 16)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.GetDiagnostics().Where(d => d.Code is not (int)ErrorCode.ERR_OperatorNeedsMatch).Verify(
+                // (12,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static implicit operator int(T x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "int").WithArguments("abstract", "9.0", "preview").WithLocation(12, 39)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperatorForTupleEquality_06([CombinatorialValues("==", "!=")] string op)
+        {
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static implicit operator bool(T x);
+}
+";
+            var source2 =
+@"
+class Test
+{
+    static void M02<T>((int, C<T>) x) where T : I1<T>
+    {
+        _ = x " + op + @" x;
+    }
+}
+
+#pragma warning disable CS0660 // 'C<T>' defines operator == or operator != but does not override Object.Equals(object o)
+#pragma warning disable CS0661 // 'C<T>' defines operator == or operator != but does not override Object.GetHashCode()
+
+class C<T>
+{
+    public static T operator == (C<T> x, C<T> y) => default;
+    public static T operator != (C<T> x, C<T> y) => default;
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation1.ToMetadataReference() });
+
+            compilation2.VerifyDiagnostics(
+                // (6,13): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                //         _ = x == x;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "x " + op + " x").WithArguments("static abstract members in interfaces").WithLocation(6, 13)
+                );
+
+            var compilation3 = CreateCompilation(source2 + source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.Regular9,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation3.VerifyDiagnostics(
+                // (21,39): error CS8703: The modifier 'abstract' is not valid for this item in C# 9.0. Please use language version 'preview' or greater.
+                //     abstract static implicit operator bool(T x);
+                Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "bool").WithArguments("abstract", "9.0", "preview").WithLocation(21, 39)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_07([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Same as ConsumeAbstractConversionOperator_03 only direction of conversion is flipped
+
+            string metadataName = ConversionOperatorName(op);
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator T(int x);
+}
+
+class Test
+{
+    static T M02<T, U>(int x) where T : U where U : I1<T>
+    {
+        return " + (needCast ? "(T)" : "") + @"x;
+    }
+
+    static T? M03<T, U>(int y) where T : struct, U where U : I1<T>
+    {
+        return " + (needCast ? "(T?)" : "") + @"y;
+    }
+
+    static T? M04<T, U>(int? y) where T : struct, U where U : I1<T>
+    {
+        return " + (needCast ? "(T?)" : "") + @"y;
+    }
+
+    static T? M05<T, U>() where T : struct, U where U : I1<T>
+    {
+        return " + (needCast ? "(T?)" : "") + @"(T?)0;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(int)",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  .locals init (T V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(int)""
+  IL_000d:  stloc.0
+  IL_000e:  br.s       IL_0010
+  IL_0010:  ldloc.0
+  IL_0011:  ret
+}
+");
+            verifier.VerifyIL("Test.M03<T, U>(int)",
+@"
+{
+  // Code size       23 (0x17)
+  .maxstack  1
+  .locals init (T? V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(int)""
+  IL_000d:  newobj     ""T?..ctor(T)""
+  IL_0012:  stloc.0
+  IL_0013:  br.s       IL_0015
+  IL_0015:  ldloc.0
+  IL_0016:  ret
+}
+");
+            verifier.VerifyIL("Test.M04<T, U>(int?)",
+@"
+{
+  // Code size       51 (0x33)
+  .maxstack  1
+  .locals init (int? V_0,
+                T? V_1,
+                T? V_2)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.0
+  IL_0003:  ldloca.s   V_0
+  IL_0005:  call       ""readonly bool int?.HasValue.get""
+  IL_000a:  brtrue.s   IL_0017
+  IL_000c:  ldloca.s   V_1
+  IL_000e:  initobj    ""T?""
+  IL_0014:  ldloc.1
+  IL_0015:  br.s       IL_002e
+  IL_0017:  ldloca.s   V_0
+  IL_0019:  call       ""readonly int int?.GetValueOrDefault()""
+  IL_001e:  constrained. ""T""
+  IL_0024:  call       ""T I1<T>." + metadataName + @"(int)""
+  IL_0029:  newobj     ""T?..ctor(T)""
+  IL_002e:  stloc.2
+  IL_002f:  br.s       IL_0031
+  IL_0031:  ldloc.2
+  IL_0032:  ret
+}
+");
+            verifier.VerifyIL("Test.M05<T, U>()",
+@"
+{
+  // Code size       23 (0x17)
+  .maxstack  1
+  .locals init (T? V_0)
+  IL_0000:  nop
+  IL_0001:  ldc.i4.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(int)""
+  IL_000d:  newobj     ""T?..ctor(T)""
+  IL_0012:  stloc.0
+  IL_0013:  br.s       IL_0015
+  IL_0015:  ldloc.0
+  IL_0016:  ret
+}
+");
+
+            compilation1 = CreateCompilation(source1, options: TestOptions.ReleaseDll,
+                                             parseOptions: TestOptions.RegularPreview,
+                                             targetFramework: TargetFramework.NetCoreApp);
+
+            verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(int)",
+@"
+{
+  // Code size       13 (0xd)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""T I1<T>." + metadataName + @"(int)""
+  IL_000c:  ret
+}
+");
+            verifier.VerifyIL("Test.M03<T, U>(int)",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""T I1<T>." + metadataName + @"(int)""
+  IL_000c:  newobj     ""T?..ctor(T)""
+  IL_0011:  ret
+}
+");
+            verifier.VerifyIL("Test.M04<T, U>(int?)",
+@"
+{
+  // Code size       45 (0x2d)
+  .maxstack  1
+  .locals init (int? V_0,
+                T? V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloca.s   V_0
+  IL_0004:  call       ""readonly bool int?.HasValue.get""
+  IL_0009:  brtrue.s   IL_0015
+  IL_000b:  ldloca.s   V_1
+  IL_000d:  initobj    ""T?""
+  IL_0013:  ldloc.1
+  IL_0014:  ret
+  IL_0015:  ldloca.s   V_0
+  IL_0017:  call       ""readonly int int?.GetValueOrDefault()""
+  IL_001c:  constrained. ""T""
+  IL_0022:  call       ""T I1<T>." + metadataName + @"(int)""
+  IL_0027:  newobj     ""T?..ctor(T)""
+  IL_002c:  ret
+}
+");
+            verifier.VerifyIL("Test.M05<T, U>()",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  IL_0000:  ldc.i4.0
+  IL_0001:  constrained. ""T""
+  IL_0007:  call       ""T I1<T>." + metadataName + @"(int)""
+  IL_000c:  newobj     ""T?..ctor(T)""
+  IL_0011:  ret
+}
+");
+
+            var tree = compilation1.SyntaxTrees.Single();
+            var model = compilation1.GetSemanticModel(tree);
+            var node = tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().First();
+
+            Assert.Equal("return " + (needCast ? "(T)" : "") + @"x;", node.ToString());
+
+            VerifyOperationTreeForNode(compilation1, model, node,
+// https://github.com/dotnet/roslyn/issues/53803: It feels like the "T" constraint is important for this operator, but it is not 
+//                                               reflected in the IOperation tree. Should we change the shape of the tree in order
+//                                               to expose this information? 
+@"
+IReturnOperation (OperationKind.Return, Type: null) (Syntax: 'return " + (needCast ? "(T)" : "") + @"x;')
+  ReturnedValue: 
+    IConversionOperation (TryCast: False, Unchecked) (OperatorMethod: T I1<T>." + metadataName + @"(System.Int32 x)) (OperationKind.Conversion, Type: T" + (needCast ? "" : ", IsImplicit") + @") (Syntax: '" + (needCast ? "(T)" : "") + @"x')
+      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: True) (MethodSymbol: T I1<T>." + metadataName + @"(System.Int32 x))
+      Operand: 
+        IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: System.Int32) (Syntax: 'x')
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_08([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Don't look in interfaces of the effective base
+
+            string metadataName = ConversionOperatorName(op);
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+class C1<T> : I1<C1<T>>
+{
+    static " + op + @" I1<C1<T>>.operator int(C1<T> x) => default;
+}
+
+class Test
+{
+    static int M02<T, U>(T x) where T : U where U : C1<T>
+    {
+        return " + (needCast ? "(int)" : "") + @"x;
+    }
+
+    static int M03<T>(C1<T> y) where T : I1<C1<T>>
+    {
+        return " + (needCast ? "(int)" : "") + @"y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var error = (op == "explicit" ? ErrorCode.ERR_NoExplicitConv : ErrorCode.ERR_NoImplicitConv);
+
+            compilation1.VerifyDiagnostics(
+                // (16,16): error CS0030: Cannot convert type 'T' to 'int'
+                //         return (int)x;
+                Diagnostic(error, (needCast ? "(int)" : "") + "x").WithArguments("T", "int").WithLocation(16, 16),
+                // (21,16): error CS0030: Cannot convert type 'C1<T>' to 'int'
+                //         return (int)y;
+                Diagnostic(error, (needCast ? "(int)" : "") + "y").WithArguments("C1<T>", "int").WithLocation(21, 16)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_09([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Same as ConsumeAbstractConversionOperator_08 only direction of conversion is flipped
+
+            string metadataName = ConversionOperatorName(op);
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator T(int x);
+}
+
+class C1<T> : I1<C1<T>>
+{
+    static " + op + @" I1<C1<T>>.operator C1<T>(int x) => default;
+}
+
+class Test
+{
+    static T M02<T, U>(int x) where T : U where U : C1<T>
+    {
+        return " + (needCast ? "(T)" : "") + @"x;
+    }
+
+    static C1<T> M03<T>(int y) where T : I1<C1<T>>
+    {
+        return " + (needCast ? "(C1<T>)" : "") + @"y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var error = (op == "explicit" ? ErrorCode.ERR_NoExplicitConv : ErrorCode.ERR_NoImplicitConv);
+
+            compilation1.VerifyDiagnostics(
+                // (16,16): error CS0030: Cannot convert type 'int' to 'T'
+                //         return (T)x;
+                Diagnostic(error, (needCast ? "(T)" : "") + "x").WithArguments("int", "T").WithLocation(16, 16),
+                // (21,16): error CS0030: Cannot convert type 'int' to 'C1<T>'
+                //         return (C1<T>)y;
+                Diagnostic(error, (needCast ? "(C1<T>)" : "") + "y").WithArguments("int", "C1<T>").WithLocation(21, 16)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_10([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Look in derived interfaces
+
+            string metadataName = ConversionOperatorName(op);
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+public interface I2<T> : I1<T> where T : I1<T>
+{}
+
+class Test
+{
+    static int M02<T, U>(T x) where T : U where U : I2<T>
+    {
+        return " + (needCast ? "(int)" : "") + @"x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  .locals init (int V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""int I1<T>." + metadataName + @"(T)""
+  IL_000d:  stloc.0
+  IL_000e:  br.s       IL_0010
+  IL_0010:  ldloc.0
+  IL_0011:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_11([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Same as ConsumeAbstractConversionOperator_10 only direction of conversion is flipped
+
+            string metadataName = ConversionOperatorName(op);
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator T(int x);
+}
+
+public interface I2<T> : I1<T> where T : I1<T>
+{}
+
+class Test
+{
+    static T M02<T, U>(int x) where T : U where U : I2<T>
+    {
+        return " + (needCast ? "(T)" : "") + @"x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(int)",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  .locals init (T V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""T I1<T>." + metadataName + @"(int)""
+  IL_000d:  stloc.0
+  IL_000e:  br.s       IL_0010
+  IL_0010:  ldloc.0
+  IL_0011:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_12([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Ignore duplicate candidates
+
+            string metadataName = ConversionOperatorName(op);
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T, U> where T : I1<T, U> where U : I1<T, U>
+{
+    abstract static " + op + @" operator U(T x);
+}
+
+class Test
+{
+    static U M02<T, U>(T x) where T : I1<T, U> where U : I1<T, U>
+    {
+        return " + (needCast ? "(U)" : "") + @"x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       18 (0x12)
+  .maxstack  1
+  .locals init (U V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  constrained. ""T""
+  IL_0008:  call       ""U I1<T, U>." + metadataName + @"(T)""
+  IL_000d:  stloc.0
+  IL_000e:  br.s       IL_0010
+  IL_0010:  ldloc.0
+  IL_0011:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_13([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Look in effective base
+
+            string metadataName = ConversionOperatorName(op);
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public class C1<T>
+{
+    public static " + op + @" operator int(C1<T> x) => default;
+}
+
+class Test
+{
+    static int M02<T, U>(T x) where T : U where U : C1<T>
+    {
+        return " + (needCast ? "(int)" : "") + @"x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       17 (0x11)
+  .maxstack  1
+  .locals init (int V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  box        ""T""
+  IL_0007:  call       ""int C1<T>." + metadataName + @"(C1<T>)""
+  IL_000c:  stloc.0
+  IL_000d:  br.s       IL_000f
+  IL_000f:  ldloc.0
+  IL_0010:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ConsumeAbstractConversionOperator_14()
+        {
+            // Same as ConsumeAbstractConversionOperator_13 only direction of conversion is flipped
+            var source1 =
+@"
+public class C1<T>
+{
+    public static explicit operator C1<T>(int x) => default;
+}
+
+class Test
+{
+    static T M02<T, U>(int x) where T : U where U : C1<T>
+    {
+        return (T)x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                    parseOptions: TestOptions.RegularPreview,
+                                                    targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(int)",
+@"
+{
+  // Code size       17 (0x11)
+  .maxstack  1
+  .locals init (T V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  call       ""C1<T> C1<T>.op_Explicit(int)""
+  IL_0007:  unbox.any  ""T""
+  IL_000c:  stloc.0
+  IL_000d:  br.s       IL_000f
+  IL_000f:  ldloc.0
+  IL_0010:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_15([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // If there is a non-trivial class constraint, interfaces are not looked at.
+
+            string metadataName = ConversionOperatorName(op);
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+public class C1 : I1<C1>
+{
+    public static " + op + @" operator int(C1 x) => default;
+}
+
+class Test
+{
+    static int M02<T, U>(T x) where T : U where U : C1, I1<C1>
+    {
+        return " + (needCast ? "(int)" : "") + @"x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(T)",
+@"
+{
+  // Code size       17 (0x11)
+  .maxstack  1
+  .locals init (int V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  box        ""T""
+  IL_0007:  call       ""int C1." + metadataName + @"(C1)""
+  IL_000c:  stloc.0
+  IL_000d:  br.s       IL_000f
+  IL_000f:  ldloc.0
+  IL_0010:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ConsumeAbstractConversionOperator_16()
+        {
+            // Same as ConsumeAbstractConversionOperator_15 only direction of conversion is flipped
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static explicit operator T(int x);
+}
+
+public class C1 : I1<C1>
+{
+    public static explicit operator C1(int x) => default;
+}
+
+class Test
+{
+    static T M02<T, U>(int x) where T : U where U : C1, I1<C1>
+    {
+        return (T)x;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                    parseOptions: TestOptions.RegularPreview,
+                                                    targetFramework: TargetFramework.NetCoreApp);
+
+            var verifier = CompileAndVerify(compilation1, verify: Verification.Skipped).VerifyDiagnostics();
+
+            verifier.VerifyIL("Test.M02<T, U>(int)",
+@"
+{
+  // Code size       17 (0x11)
+  .maxstack  1
+  .locals init (T V_0)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  call       ""C1 C1.op_Explicit(int)""
+  IL_0007:  unbox.any  ""T""
+  IL_000c:  stloc.0
+  IL_000d:  br.s       IL_000f
+  IL_000f:  ldloc.0
+  IL_0010:  ret
+}
+");
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_17([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // If there is a non-trivial class constraint, interfaces are not looked at.
+
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator int(T x);
+}
+
+public class C1 
+{
+}
+
+class Test
+{
+    static int M02<T, U>(T x) where T : U where U : C1, I1<T>
+    {
+        return " + (needCast ? "(int)" : "") + @"x;
+    }
+
+    static int M03<T, U>(T y) where T : U where U : I1<T>
+    {
+        return " + (needCast ? "(int)" : "") + @"y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (15,16): error CS0030: Cannot convert type 'T' to 'int'
+                //         return (int)x;
+                Diagnostic((op == "explicit" ? ErrorCode.ERR_NoExplicitConv : ErrorCode.ERR_NoImplicitConv), (needCast ? "(int)" : "") + "x").WithArguments("T", "int").WithLocation(15, 16)
+                );
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void ConsumeAbstractConversionOperator_18([CombinatorialValues("implicit", "explicit")] string op)
+        {
+            // Same as ConsumeAbstractConversionOperator_17 only direction of conversion is flipped
+
+            bool needCast = op == "explicit";
+
+            var source1 =
+@"
+public interface I1<T> where T : I1<T>
+{
+    abstract static " + op + @" operator T(int x);
+}
+
+public class C1 
+{
+}
+
+class Test
+{
+    static T M02<T, U>(int x) where T : U where U : C1, I1<T>
+    {
+        return " + (needCast ? "(T)" : "") + @"x;
+    }
+
+    static T M03<T, U>(int y) where T : U where U : I1<T>
+    {
+        return " + (needCast ? "(T)" : "") + @"y;
+    }
+}
+";
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+            compilation1.VerifyDiagnostics(
+                // (15,16): error CS0030: Cannot convert type 'int' to 'T'
+                //         return (T)x;
+                Diagnostic((op == "explicit" ? ErrorCode.ERR_NoExplicitConv : ErrorCode.ERR_NoImplicitConv), (needCast ? "(T)" : "") + "x").WithArguments("int", "T").WithLocation(15, 16)
+                );
+        }
+
+        [Fact]
+        [WorkItem(53802, "https://github.com/dotnet/roslyn/issues/53802")]
+        public void TestAmbiguousImplementationMethod_01()
+        {
+            var source1 = @"
+public interface Interface<T, U>
+{
+    abstract static void Method(int i);
+    abstract static void Method(T i);
+    abstract static void Method(U i);
+}
+
+public class Base<T> : Interface<T, T>
+{
+    public static void Method(int i) { }
+    public static void Method(T i) { }
+}
+
+public class Derived : Base<int>, Interface<int, int>
+{
+}
+
+class YetAnother : Interface<int, int>
+{
+    public static void Method(int i) { }
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var b = module.GlobalNamespace.GetTypeMember("Base");
+                var bI = b.Interfaces().Single();
+                var biMethods = bI.GetMembers();
+
+                Assert.Equal("void Interface<T, U>.Method(System.Int32 i)", biMethods[0].OriginalDefinition.ToTestDisplayString());
+                Assert.Equal("void Interface<T, U>.Method(T i)", biMethods[1].OriginalDefinition.ToTestDisplayString());
+                Assert.Equal("void Interface<T, U>.Method(U i)", biMethods[2].OriginalDefinition.ToTestDisplayString());
+
+                var bM1 = b.FindImplementationForInterfaceMember(biMethods[0]);
+
+                Assert.Equal("void Base<T>.Method(System.Int32 i)", bM1.ToTestDisplayString());
+
+                var bM2 = b.FindImplementationForInterfaceMember(biMethods[1]);
+
+                Assert.Equal("void Base<T>.Method(T i)", bM2.ToTestDisplayString());
+                Assert.Same(bM2, b.FindImplementationForInterfaceMember(biMethods[2]));
+
+                var bM1Impl = ((MethodSymbol)bM1).ExplicitInterfaceImplementations;
+                var bM2Impl = ((MethodSymbol)bM2).ExplicitInterfaceImplementations;
+
+                if (module is PEModuleSymbol)
+                {
+                    Assert.Equal(biMethods[0], bM1Impl.Single());
+
+                    Assert.Equal(2, bM2Impl.Length);
+                    Assert.Equal(biMethods[1], bM2Impl[0]);
+                    Assert.Equal(biMethods[2], bM2Impl[1]);
+                }
+                else
+                {
+                    Assert.Empty(bM1Impl);
+                    Assert.Empty(bM2Impl);
+                }
+
+                var d = module.GlobalNamespace.GetTypeMember("Derived");
+                var dB = d.BaseTypeNoUseSiteDiagnostics;
+                var dI = d.Interfaces().Single();
+                var diMethods = dI.GetMembers();
+
+                Assert.Equal("void Interface<T, U>.Method(System.Int32 i)", diMethods[0].OriginalDefinition.ToTestDisplayString());
+                Assert.Equal("void Interface<T, U>.Method(T i)", diMethods[1].OriginalDefinition.ToTestDisplayString());
+                Assert.Equal("void Interface<T, U>.Method(U i)", diMethods[2].OriginalDefinition.ToTestDisplayString());
+
+                var dM1 = d.FindImplementationForInterfaceMember(diMethods[0]);
+
+                Assert.Same(bM1, dM1.OriginalDefinition);
+
+                var dM2 = d.FindImplementationForInterfaceMember(diMethods[1]);
+
+                Assert.Same(bM2, dM2.OriginalDefinition);
+                Assert.Same(bM2, d.FindImplementationForInterfaceMember(diMethods[2]).OriginalDefinition);
+            }
+        }
+
+        [Fact]
+        [WorkItem(53802, "https://github.com/dotnet/roslyn/issues/53802")]
+        public void TestAmbiguousImplementationMethod_02()
+        {
+            var source0 = @"
+public interface Interface<T, U>
+{
+    abstract static void Method(int i);
+    abstract static void Method(T i);
+    abstract static void Method(U i);
+}
+
+public class Base<T> : Interface<T, T>
+{
+    public static void Method(int i) { }
+    public static void Method(T i) { }
+}
+";
+
+            var compilation0 = CreateCompilation(source0, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation0.VerifyDiagnostics();
+
+            var source1 = @"
+public class Derived : Base<int>, Interface<int, int>
+{
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation0.EmitToImageReference() });
+
+            CompileAndVerify(compilation1, sourceSymbolValidator: validate, symbolValidator: validate, verify: Verification.Skipped).VerifyDiagnostics();
+
+            void validate(ModuleSymbol module)
+            {
+                var d = module.GlobalNamespace.GetTypeMember("Derived");
+                var dB = d.BaseTypeNoUseSiteDiagnostics;
+                var dI = d.Interfaces().Single();
+                var diMethods = dI.GetMembers();
+
+                Assert.Equal("void Interface<T, U>.Method(System.Int32 i)", diMethods[0].OriginalDefinition.ToTestDisplayString());
+                Assert.Equal("void Interface<T, U>.Method(T i)", diMethods[1].OriginalDefinition.ToTestDisplayString());
+                Assert.Equal("void Interface<T, U>.Method(U i)", diMethods[2].OriginalDefinition.ToTestDisplayString());
+
+                var dM1 = d.FindImplementationForInterfaceMember(diMethods[0]);
+
+                Assert.Equal("void Base<T>.Method(System.Int32 i)", dM1.OriginalDefinition.ToTestDisplayString());
+
+                var dM2 = d.FindImplementationForInterfaceMember(diMethods[1]);
+
+                Assert.Equal("void Base<T>.Method(T i)", dM2.OriginalDefinition.ToTestDisplayString());
+                Assert.Same(dM2, d.FindImplementationForInterfaceMember(diMethods[2]));
+
+                var dM1Impl = ((MethodSymbol)dM1).ExplicitInterfaceImplementations;
+                var dM2Impl = ((MethodSymbol)dM2).ExplicitInterfaceImplementations;
+
+                Assert.Equal(diMethods[0], dM1Impl.Single());
+
+                Assert.Equal(2, dM2Impl.Length);
+                Assert.Equal(diMethods[1], dM2Impl[0]);
+                Assert.Equal(diMethods[2], dM2Impl[1]);
+            }
+        }
+
+        [Fact]
+        [WorkItem(53802, "https://github.com/dotnet/roslyn/issues/53802")]
+        public void TestAmbiguousImplementationMethod_03()
+        {
+            var source0 = @"
+public interface Interface<T, U>
+{
+    abstract static void Method(int i);
+    abstract static void Method(T i);
+    abstract static void Method(U i);
+}
+
+public class Base<T> : Interface<T, T>
+{
+    public static void Method(int i) { }
+    public static void Method(T i) { }
+}
+";
+
+            var compilation0 = CreateCompilation(source0, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { CreateEmptyCompilation("").ToMetadataReference() });
+
+            compilation0.VerifyDiagnostics();
+
+            var source1 = @"
+public class Derived : Base<int>, Interface<int, int>
+{
+}
+";
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp,
+                                                 references: new[] { compilation0.ToMetadataReference() });
+
+            var d = compilation1.GlobalNamespace.GetTypeMember("Derived");
+            var dB = d.BaseTypeNoUseSiteDiagnostics;
+            var dI = d.Interfaces().Single();
+            var diMethods = dI.GetMembers();
+
+            Assert.IsType<RetargetingNamedTypeSymbol>(dB.OriginalDefinition);
+
+            Assert.Equal("void Interface<T, U>.Method(System.Int32 i)", diMethods[0].OriginalDefinition.ToTestDisplayString());
+            Assert.Equal("void Interface<T, U>.Method(T i)", diMethods[1].OriginalDefinition.ToTestDisplayString());
+            Assert.Equal("void Interface<T, U>.Method(U i)", diMethods[2].OriginalDefinition.ToTestDisplayString());
+
+            var dM1 = d.FindImplementationForInterfaceMember(diMethods[0]);
+
+            Assert.Equal("void Base<T>.Method(System.Int32 i)", dM1.OriginalDefinition.ToTestDisplayString());
+
+            var dM2 = d.FindImplementationForInterfaceMember(diMethods[1]);
+
+            Assert.Equal("void Base<T>.Method(T i)", dM2.OriginalDefinition.ToTestDisplayString());
+            Assert.Equal(dM2, d.FindImplementationForInterfaceMember(diMethods[2]));
+
+            var dM1Impl = ((MethodSymbol)dM1).ExplicitInterfaceImplementations;
+            var dM2Impl = ((MethodSymbol)dM2).ExplicitInterfaceImplementations;
+
+            Assert.Empty(dM1Impl);
+            Assert.Empty(dM2Impl);
+        }
+
+        [Fact]
+        [WorkItem(53802, "https://github.com/dotnet/roslyn/issues/53802")]
+        public void TestAmbiguousImplementationMethod_04()
+        {
+            var source2 = @"
+public interface Interface<T, U>
+{
+    abstract static void Method(int i);
+    abstract static void Method(T i);
+    abstract static void Method(U i);
+}
+
+class Other : Interface<int, int>
+{
+    static void Interface<int, int>.Method(int i) { }
+}
+";
+
+            var compilation2 = CreateCompilation(source2, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation2.VerifyDiagnostics(
+                // (9,15): error CS0535: 'Other' does not implement interface member 'Interface<int, int>.Method(int)'
+                // class Other : Interface<int, int>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "Interface<int, int>").WithArguments("Other", "Interface<int, int>.Method(int)").WithLocation(9, 15),
+                // (9,15): error CS0535: 'Other' does not implement interface member 'Interface<int, int>.Method(int)'
+                // class Other : Interface<int, int>
+                Diagnostic(ErrorCode.ERR_UnimplementedInterfaceMember, "Interface<int, int>").WithArguments("Other", "Interface<int, int>.Method(int)").WithLocation(9, 15),
+                // (11,37): warning CS0473: Explicit interface implementation 'Other.Interface<int, int>.Method(int)' matches more than one interface member. Which interface member is actually chosen is implementation-dependent. Consider using a non-explicit implementation instead.
+                //     static void Interface<int, int>.Method(int i) { }
+                Diagnostic(ErrorCode.WRN_ExplicitImplCollision, "Method").WithArguments("Other.Interface<int, int>.Method(int)").WithLocation(11, 37)
+                );
+        }
+
+        [Fact]
+        public void UnmanagedCallersOnly_01()
+        {
+            var source2 = @"
+using System.Runtime.InteropServices;
+
+public interface I1
+{
+    [UnmanagedCallersOnly] abstract static void M1();
+    [UnmanagedCallersOnly] abstract static int operator +(I1 x);
+    [UnmanagedCallersOnly] abstract static int operator +(I1 x, I1 y);
+}
+
+public interface I2<T> where T : I2<T>
+{
+    [UnmanagedCallersOnly] abstract static implicit operator int(T i);
+    [UnmanagedCallersOnly] abstract static explicit operator T(int i);
+}
+";
+
+            var compilation2 = CreateCompilation(new[] { source2, UnmanagedCallersOnlyAttributeDefinition }, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation2.VerifyDiagnostics(
+                // (6,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] abstract static void M1();
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(6, 6),
+                // (7,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] abstract static int operator +(I1 x);
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(7, 6),
+                // (8,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] abstract static int operator +(I1 x, I1 y);
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(8, 6),
+                // (13,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] abstract static implicit operator int(T i);
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(13, 6),
+                // (14,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] abstract static explicit operator T(int i);
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(14, 6)
+                );
+        }
+
+        [Fact]
+        [WorkItem(54113, "https://github.com/dotnet/roslyn/issues/54113")]
+        public void UnmanagedCallersOnly_02()
+        {
+            var ilSource = @"
+.class public auto ansi sealed beforefieldinit System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute
+    extends [mscorlib]System.Attribute
+{
+    .custom instance void [mscorlib]System.AttributeUsageAttribute::.ctor(valuetype [mscorlib]System.AttributeTargets) = (
+        01 00 40 00 00 00 01 00 54 02 09 49 6e 68 65 72
+        69 74 65 64 00
+    )
+    .field public class [mscorlib]System.Type[] CallConvs
+    .field public string EntryPoint
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        ldarg.0
+        call instance void [mscorlib]System.Attribute::.ctor()
+        ret
+    }
+}
+
+.class interface public auto ansi abstract I1
+{
+    .method public hidebysig abstract virtual static 
+        void M1 () cil managed 
+    {
+        // [System.Runtime.InteropServices.UnmanagedCallersOnly]
+        .custom instance void System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute::.ctor() = (
+            01 00 00 00
+        )
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        int32 op_UnaryPlus (
+            class I1 x
+        ) cil managed 
+    {
+        // [System.Runtime.InteropServices.UnmanagedCallersOnly]
+        .custom instance void System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute::.ctor() = (
+            01 00 00 00
+        )
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        int32 op_Addition (
+            class I1 x,
+            class I1 y
+        ) cil managed 
+    {
+        // [System.Runtime.InteropServices.UnmanagedCallersOnly]
+        .custom instance void System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute::.ctor() = (
+            01 00 00 00
+        )
+    }
+}
+
+.class interface public auto ansi abstract I2`1<(class I2`1<!T>) T>
+{
+    .method public hidebysig specialname abstract virtual static 
+        int32 op_Implicit (
+            !T i
+        ) cil managed 
+    {
+        // [System.Runtime.InteropServices.UnmanagedCallersOnly]
+        .custom instance void System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute::.ctor() = (
+            01 00 00 00
+        )
+    }
+
+    .method public hidebysig specialname abstract virtual static 
+        !T op_Explicit (
+            int32 i
+        ) cil managed 
+    {
+        // [System.Runtime.InteropServices.UnmanagedCallersOnly]
+        .custom instance void System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute::.ctor() = (
+            01 00 00 00
+        )
+    }
+}
+";
+
+            var source1 =
+@"
+class Test
+{
+    static void M02<T>(T x, T y) where T : I1
+    {
+        T.M1();
+        _ = +x;
+        _ = x + y;
+    }
+
+    static int M03<T>(T x) where T : I2<T>
+    {
+        _ = (T)x;
+        return x;
+    }
+}
+";
+            var compilation1 = CreateCompilationWithIL(source1, ilSource, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            // Conversions aren't flagged due to https://github.com/dotnet/roslyn/issues/54113.
+            compilation1.VerifyDiagnostics(
+                // (6,11): error CS0570: 'I1.M1()' is not supported by the language
+                //         T.M1();
+                Diagnostic(ErrorCode.ERR_BindToBogus, "M1").WithArguments("I1.M1()").WithLocation(6, 11),
+                // (7,13): error CS0570: 'I1.operator +(I1)' is not supported by the language
+                //         _ = +x;
+                Diagnostic(ErrorCode.ERR_BindToBogus, "+x").WithArguments("I1.operator +(I1)").WithLocation(7, 13),
+                // (8,13): error CS0570: 'I1.operator +(I1, I1)' is not supported by the language
+                //         _ = x + y;
+                Diagnostic(ErrorCode.ERR_BindToBogus, "x + y").WithArguments("I1.operator +(I1, I1)").WithLocation(8, 13)
+                );
+        }
+
+        [Fact]
+        public void UnmanagedCallersOnly_03()
+        {
+            var source2 = @"
+using System.Runtime.InteropServices;
+
+public interface I1<T> where T : I1<T>
+{
+    abstract static void M1();
+    abstract static int operator +(T x);
+    abstract static int operator +(T x, T y);
+    abstract static implicit operator int(T i);
+    abstract static explicit operator T(int i);
+}
+
+class C : I1<C>
+{
+    [UnmanagedCallersOnly] public static void M1() {}
+    [UnmanagedCallersOnly] public static int operator +(C x) => 0;
+    [UnmanagedCallersOnly] public static int operator +(C x, C y) => 0;
+    [UnmanagedCallersOnly] public static implicit operator int(C i) => 0;
+    [UnmanagedCallersOnly] public static explicit operator C(int i) => null;
+}
+";
+
+            var compilation2 = CreateCompilation(new[] { source2, UnmanagedCallersOnlyAttributeDefinition }, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation2.VerifyDiagnostics(
+                // (15,47): error CS8932: 'UnmanagedCallersOnly' method 'C.M1()' cannot implement interface member 'I1<C>.M1()' in type 'C'
+                //     [UnmanagedCallersOnly] public static void M1() {}
+                Diagnostic(ErrorCode.ERR_InterfaceImplementedByUnmanagedCallersOnlyMethod, "M1").WithArguments("C.M1()", "I1<C>.M1()", "C").WithLocation(15, 47),
+                // (16,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] public static int operator +(C x) => 0;
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(16, 6),
+                // (17,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] public static int operator +(C x, C y) => 0;
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(17, 6),
+                // (18,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] public static implicit operator int(C i) => 0;
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(18, 6),
+                // (19,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] public static explicit operator C(int i) => null;
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(19, 6)
+                );
+        }
+
+        [Fact]
+        public void UnmanagedCallersOnly_04()
+        {
+            var source2 = @"
+using System.Runtime.InteropServices;
+
+public interface I1<T> where T : I1<T>
+{
+    abstract static void M1();
+    abstract static int operator +(T x);
+    abstract static int operator +(T x, T y);
+    abstract static implicit operator int(T i);
+    abstract static explicit operator T(int i);
+}
+
+class C : I1<C>
+{
+    [UnmanagedCallersOnly] static void I1<C>.M1() {}
+    [UnmanagedCallersOnly] static int I1<C>.operator +(C x) => 0;
+    [UnmanagedCallersOnly] static int I1<C>.operator +(C x, C y) => 0;
+    [UnmanagedCallersOnly] static implicit I1<C>.operator int(C i) => 0;
+    [UnmanagedCallersOnly] static explicit I1<C>.operator C(int i) => null;
+}
+";
+
+            var compilation2 = CreateCompilation(new[] { source2, UnmanagedCallersOnlyAttributeDefinition }, options: TestOptions.DebugDll,
+                                                 parseOptions: TestOptions.RegularPreview,
+                                                 targetFramework: TargetFramework.NetCoreApp);
+
+            compilation2.VerifyDiagnostics(
+                // (15,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] static void I1<C>.M1() {}
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(15, 6),
+                // (16,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] static int I1<C>.operator +(C x) => 0;
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(16, 6),
+                // (17,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] static int I1<C>.operator +(C x, C y) => 0;
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(17, 6),
+                // (18,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] static implicit I1<C>.operator int(C i) => 0;
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(18, 6),
+                // (19,6): error CS8896: 'UnmanagedCallersOnly' can only be applied to ordinary static non-abstract methods or static local functions.
+                //     [UnmanagedCallersOnly] static explicit I1<C>.operator C(int i) => null;
+                Diagnostic(ErrorCode.ERR_UnmanagedCallersOnlyRequiresStatic, "UnmanagedCallersOnly").WithLocation(19, 6)
+                );
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
index af1f6686bad3d..167aad83f0519 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
@@ -1766,9 +1766,6 @@ internal int P2 { static set { } }
                 // (3,23): error CS8503: The modifier 'public' is not valid for this item in C# 7. Please use language version '8.0' or greater.
                 //     public static int P1 { get; }
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P1").WithArguments("public", "7.0", "8.0").WithLocation(3, 23),
-                // (3,28): error CS8652: The feature 'default interface implementation' is not available in C# 7. Please use language version 8.0 or greater.
-                //     public static int P1 { get; }
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "get").WithArguments("default interface implementation", "8.0").WithLocation(3, 28),
                 // (4,18): error CS8503: The modifier 'abstract' is not valid for this item in C# 7. Please use language version '8.0' or greater.
                 //     abstract int P2 { static set; }
                 Diagnostic(ErrorCode.ERR_InvalidModifierForLanguageVersion, "P2").WithArguments("abstract", "7.0", "8.0").WithLocation(4, 18),
@@ -2082,8 +2079,17 @@ public static int Main()
     }
 }
 ";
-            var comp = DiagnosticsUtils.VerifyErrorsAndGetCompilationWithMscorlib(text,
-                new ErrorDescription { Code = (int)ErrorCode.ERR_StaticNotVirtual, Line = 9, Column = 37 });
+            CreateCompilation(text, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
+                // (7,18): error CS0534: 'MyClass2' does not implement inherited abstract member 'MyClass.MyMethod()'
+                //     public class MyClass2 : MyClass
+                Diagnostic(ErrorCode.ERR_UnimplementedAbstractMethod, "MyClass2").WithArguments("MyNamespace.MyClass2", "MyNamespace.MyClass.MyMethod()").WithLocation(7, 18),
+                // (9,37): error CS0112: A static member cannot be marked as 'override'
+                //         override public static void MyMethod()   // CS0112, remove static keyword
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "MyMethod").WithArguments("override").WithLocation(9, 37),
+                // (9,37): warning CS0114: 'MyClass2.MyMethod()' hides inherited member 'MyClass.MyMethod()'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.
+                //         override public static void MyMethod()   // CS0112, remove static keyword
+                Diagnostic(ErrorCode.WRN_NewOrOverrideExpected, "MyMethod").WithArguments("MyNamespace.MyClass2.MyMethod()", "MyNamespace.MyClass.MyMethod()").WithLocation(9, 37)
+                );
         }
 
         [Fact]
@@ -2103,24 +2109,30 @@ class B : A
 ";
             var tree = Parse(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5));
             CreateCompilation(tree).VerifyDiagnostics(
-    // (78): error CS0112: A static member 'B.P' cannot be marked as override, virtual, or abstract
-    //     protected static override object P { get { return null; } }
-    Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P").WithArguments("B.P").WithLocation(7, 38),
-    // (8,34): error CS0112: A static member 'B.Q' cannot be marked as override, virtual, or abstract
-    //     public static virtual object Q { get; }
-    Diagnostic(ErrorCode.ERR_StaticNotVirtual, "Q").WithArguments("B.Q").WithLocation(8, 34),
-    // (8,34): error CS8026: Feature 'readonly automatically implemented properties' is not available in C# 5. Please use language version 6 or greater.
-    //     public static virtual object Q { get; }
-    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion5, "Q").WithArguments("readonly automatically implemented properties", "6").WithLocation(8, 34),
-    // (9,37): error CS0112: A static member 'B.R' cannot be marked as override, virtual, or abstract
-    //     internal static abstract object R { get; set; }
-    Diagnostic(ErrorCode.ERR_StaticNotVirtual, "R").WithArguments("B.R").WithLocation(9, 37),
-    // (9,41): error CS0513: 'B.R.get' is abstract but it is contained in non-abstract type 'B'
-    //     internal static abstract object R { get; set; }
-    Diagnostic(ErrorCode.ERR_AbstractInConcreteClass, "get").WithArguments("B.R.get", "B").WithLocation(9, 41),
-    // (9,46): error CS0513: 'B.R.set' is abstract but it is contained in non-abstract type 'B'
-    //     internal static abstract object R { get; set; }
-    Diagnostic(ErrorCode.ERR_AbstractInConcreteClass, "set").WithArguments("B.R.set", "B").WithLocation(9, 46));
+                // (5,7): error CS0534: 'B' does not implement inherited abstract member 'A.P.get'
+                // class B : A
+                Diagnostic(ErrorCode.ERR_UnimplementedAbstractMethod, "B").WithArguments("B", "A.P.get").WithLocation(5, 7),
+                // (7,38): error CS0112: A static member cannot be marked as 'override'
+                //     protected static override object P { get { return null; } }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P").WithArguments("override").WithLocation(7, 38),
+                // (7,38): warning CS0114: 'B.P' hides inherited member 'A.P'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.
+                //     protected static override object P { get { return null; } }
+                Diagnostic(ErrorCode.WRN_NewOrOverrideExpected, "P").WithArguments("B.P", "A.P").WithLocation(7, 38),
+                // (8,34): error CS0112: A static member cannot be marked as 'virtual'
+                //     public static virtual object Q { get; }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "Q").WithArguments("virtual").WithLocation(8, 34),
+                // (8,34): error CS8026: Feature 'readonly automatically implemented properties' is not available in C# 5. Please use language version 6 or greater.
+                //     public static virtual object Q { get; }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion5, "Q").WithArguments("readonly automatically implemented properties", "6").WithLocation(8, 34),
+                // (9,37): error CS0112: A static member cannot be marked as 'abstract'
+                //     internal static abstract object R { get; set; }
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "R").WithArguments("abstract").WithLocation(9, 37),
+                // (9,41): error CS0513: 'B.R.get' is abstract but it is contained in non-abstract type 'B'
+                //     internal static abstract object R { get; set; }
+                Diagnostic(ErrorCode.ERR_AbstractInConcreteClass, "get").WithArguments("B.R.get", "B").WithLocation(9, 41),
+                // (9,46): error CS0513: 'B.R.set' is abstract but it is contained in non-abstract type 'B'
+                //     internal static abstract object R { get; set; }
+                Diagnostic(ErrorCode.ERR_AbstractInConcreteClass, "set").WithArguments("B.R.set", "B").WithLocation(9, 46));
         }
 
         [Fact]
@@ -2138,12 +2150,29 @@ abstract class B : A
     internal static abstract event System.Action R;
 }
 ";
-            var comp = DiagnosticsUtils.VerifyErrorsAndGetCompilationWithMscorlib(text,
-                new ErrorDescription { Code = (int)ErrorCode.ERR_StaticNotVirtual, Line = 7, Column = 51 },
-                new ErrorDescription { Code = (int)ErrorCode.ERR_StaticNotVirtual, Line = 8, Column = 47 },
-                new ErrorDescription { Code = (int)ErrorCode.ERR_StaticNotVirtual, Line = 9, Column = 50 },
-                new ErrorDescription { Code = (int)ErrorCode.WRN_UnreferencedEvent, Line = 7, Column = 51, IsWarning = true },
-                new ErrorDescription { Code = (int)ErrorCode.WRN_UnreferencedEvent, Line = 8, Column = 47, IsWarning = true });
+            CreateCompilation(text, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
+                // (7,51): error CS0112: A static member cannot be marked as 'override'
+                //     protected static override event System.Action P;
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "P").WithArguments("override").WithLocation(7, 51),
+                // (7,51): error CS0533: 'B.P' hides inherited abstract member 'A.P'
+                //     protected static override event System.Action P;
+                Diagnostic(ErrorCode.ERR_HidingAbstractMethod, "P").WithArguments("B.P", "A.P").WithLocation(7, 51),
+                // (7,51): warning CS0114: 'B.P' hides inherited member 'A.P'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.
+                //     protected static override event System.Action P;
+                Diagnostic(ErrorCode.WRN_NewOrOverrideExpected, "P").WithArguments("B.P", "A.P").WithLocation(7, 51),
+                // (7,51): warning CS0067: The event 'B.P' is never used
+                //     protected static override event System.Action P;
+                Diagnostic(ErrorCode.WRN_UnreferencedEvent, "P").WithArguments("B.P").WithLocation(7, 51),
+                // (8,47): error CS0112: A static member cannot be marked as 'virtual'
+                //     public static virtual event System.Action Q;
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "Q").WithArguments("virtual").WithLocation(8, 47),
+                // (8,47): warning CS0067: The event 'B.Q' is never used
+                //     public static virtual event System.Action Q;
+                Diagnostic(ErrorCode.WRN_UnreferencedEvent, "Q").WithArguments("B.Q").WithLocation(8, 47),
+                // (9,50): error CS0112: A static member cannot be marked as 'abstract'
+                //     internal static abstract event System.Action R;
+                Diagnostic(ErrorCode.ERR_StaticNotVirtual, "R").WithArguments("abstract").WithLocation(9, 50)
+                );
         }
 
         [Fact]
@@ -10362,11 +10391,11 @@ public struct S
 ";
             var comp = CreateCompilation(text);
             comp.VerifyDiagnostics(
-// (4,37): error CS0555: User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type
+// (4,37): error CS0555: User-defined operator cannot convert a type to itself
 //     public static implicit operator MyClass(MyClass aa)   // CS0555
 Diagnostic(ErrorCode.ERR_IdentityConversion, "MyClass"),
 
-// (11,37): error CS0555: User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type
+// (11,37): error CS0555: User-defined operator cannot convert a type to itself
 //     public static implicit operator S?(S s) { return s; }
 Diagnostic(ErrorCode.ERR_IdentityConversion, "S?")
                 );
diff --git a/src/Compilers/CSharp/Test/Syntax/Diagnostics/LineSpanDirectiveTests.cs b/src/Compilers/CSharp/Test/Syntax/Diagnostics/LineSpanDirectiveTests.cs
new file mode 100644
index 0000000000000..511f88fc20c2e
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Syntax/Diagnostics/LineSpanDirectiveTests.cs
@@ -0,0 +1,605 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public class LineSpanDirectiveTests : CSharpTestBase
+    {
+        [Fact]
+        public void LineSpanDirective_SingleLine()
+        {
+            string sourceA =
+@"         A1(); A2(); A3(); //123
+//4567890
+".NormalizeLineEndings();
+            var textA = SourceText.From(sourceA);
+
+            string sourceB =
+@"class Program
+{
+    static void Main()
+    {
+#line (1, 16) - (1, 26) 15 ""a.cs""
+        B1(); A2(); A3(); B4();
+        B5();
+    }
+}
+".NormalizeLineEndings();
+
+            var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "b.cs");
+            treeB.GetDiagnostics().Verify();
+
+            var actualLineMappings = GetLineMappings(treeB);
+            var expectedLineMappings = new[]
+            {
+                "(0,0)-(3,7) -> : (0,0)-(3,7)",
+                "(5,0)-(9,0),14 -> a.cs: (0,15)-(0,26)",
+            };
+            AssertEx.Equal(expectedLineMappings, actualLineMappings);
+
+            var statements = GetStatementsAndExpressionBodies(treeB);
+            var actualTextSpans = statements.SelectAsArray(s => GetTextMapping(textA, treeB, s));
+            var expectedTextSpans = new[]
+            {
+                (@"B1();", @"[|A2(); A3();|]"),
+                (@"A2();", @"[|A2(); A3();|]"),
+                (@"A3();", @"[|A3();|]"),
+                (@"B4();", @"[|//123|]"),
+                (@"B5();", @"[|0|]"),
+            };
+            AssertEx.Equal(expectedTextSpans, actualTextSpans);
+        }
+
+        [Fact]
+        public void LineSpanDirective_MultiLine()
+        {
+            string sourceA =
+@"         A1(); A2(); A3(); //123
+//4567890
+//ABCDEF
+".NormalizeLineEndings();
+            var textA = SourceText.From(sourceA);
+
+            string sourceB =
+@"class Program
+{
+    static void Main()
+    {
+#line (1, 16) - (5, 26) 15 ""a.cs""
+        B1(); A2(); A3(); B4();
+        B5();
+    }
+}
+".NormalizeLineEndings();
+
+            var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "b.cs");
+            treeB.GetDiagnostics().Verify();
+
+            var actualLineMappings = GetLineMappings(treeB);
+            var expectedLineMappings = new[]
+            {
+                "(0,0)-(3,7) -> : (0,0)-(3,7)",
+                "(5,0)-(9,0),14 -> a.cs: (0,15)-(4,26)",
+            };
+            AssertEx.Equal(expectedLineMappings, actualLineMappings);
+
+            var statements = GetStatementsAndExpressionBodies(treeB);
+            var actualTextSpans = statements.SelectAsArray(s => GetTextMapping(textA, treeB, s));
+            var expectedTextSpans = new[]
+            {
+                (@"B1();", @"[|A2(); A3(); //123
+//4567890
+//ABCDEF
+|]".NormalizeLineEndings()),
+                (@"A2();", @"[|A2(); A3(); //123
+//4567890
+//ABCDEF
+|]".NormalizeLineEndings()),
+                (@"A3();", @"[|A3();|]"),
+                (@"B4();", @"[|//123|]"),
+                (@"B5();", @"[|0|]"),
+            };
+            AssertEx.Equal(expectedTextSpans, actualTextSpans);
+        }
+
+        [Fact]
+        public void InvalidSpans()
+        {
+            string source =
+@"class Program
+{
+    static void Main()
+    {
+#line (10, 20) - (10, 20) ""A""
+        F();
+#line (10, 20) - (10, 19) ""B""
+        F();
+#line (10, 20) - (9, 20) ""C""
+        F();
+#line (10, 20) - (11, 19) ""D""
+        F();
+    }
+    static void F() { }
+}".NormalizeLineEndings();
+
+            var tree = SyntaxFactory.ParseSyntaxTree(source);
+            var comp = CreateCompilation(tree);
+            comp.VerifyDiagnostics(
+                // (9,18): error CS8939: The #line directive end position must be greater than or equal to the start position
+                // #line (10, 20) - (9, 20) "C"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveEndLessThanStart, "(9, 20)").WithLocation(9, 18),
+                // A(11,18): error CS8939: The #line directive end position must be greater than or equal to the start position
+                // #line (10, 20) - (10, 19) "B"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveEndLessThanStart, "(10, 19)").WithLocation(11, 18));
+
+            var actualLineMappings = GetLineMappings(tree);
+            var expectedLineMappings = new[]
+            {
+                "(0,0)-(3,7) -> : (0,0)-(3,7)",
+                "(5,0)-(5,14) -> A: (9,19)-(9,20)",
+                "(7,0)-(7,14) -> : (7,0)-(7,14)",
+                "(9,0)-(9,14) -> : (9,0)-(9,14)",
+                "(11,0)-(14,1) -> D: (9,19)-(10,19)",
+            };
+            AssertEx.Equal(expectedLineMappings, actualLineMappings);
+        }
+
+        // 1. First and subsequent spans
+        [WorkItem(4747, "https://github.com/dotnet/csharplang/issues/4747")]
+        [Fact]
+        public void LineSpanDirective_Example1()
+        {
+            string sourceA =
+@"         A();B(
+);C();
+    D();
+".NormalizeLineEndings();
+            var textA = SourceText.From(sourceA);
+
+            string sourceB =
+@"class Program
+{
+ static void Main() {
+#line (1,10)-(1,15) 3 ""a"" // 3
+  A();B(              // 4
+);C();                // 5
+    D();              // 6
+ }
+ static void A() { }
+ static void B() { }
+ static void C() { }
+ static void D() { }
+}".NormalizeLineEndings();
+
+            var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "b.cs");
+            treeB.GetDiagnostics().Verify();
+
+            var actualLineMappings = GetLineMappings(treeB);
+            var expectedLineMappings = new[]
+            {
+                "(0,0)-(2,23) -> : (0,0)-(2,23)",
+                "(4,0)-(12,1),2 -> a: (0,9)-(0,15)",
+            };
+            AssertEx.Equal(expectedLineMappings, actualLineMappings);
+
+            var statements = GetStatementsAndExpressionBodies(treeB);
+            var actualTextSpans = statements.SelectAsArray(s => GetTextMapping(textA, treeB, s));
+            var expectedTextSpans = new[]
+            {
+                (@"A();", @"[|A();B(|]"),
+                (@"B(              // 4...", @"[|B(
+);|]".NormalizeLineEndings()),
+                (@"C();", @"[|C();|]"),
+                (@"D();", @"[|D();|]"),
+            };
+            AssertEx.Equal(expectedTextSpans, actualTextSpans);
+        }
+
+        // 2. Character offset
+        [WorkItem(4747, "https://github.com/dotnet/csharplang/issues/4747")]
+        [Fact]
+        public void LineSpanDirective_Example2()
+        {
+            string sourceA =
+@"@page ""/""
+@F(() => 1+1,
+   () => 2+2
+)".NormalizeLineEndings();
+            var textA = SourceText.From(sourceA);
+
+            string sourceB =
+@"#line hidden
+class Page
+{
+void Render()
+{
+#line (2,2)-(4,1) 16 ""page.razor"" // spanof('F(...)')
+  _builder.Add(F(() => 1+1,       // 5
+   () => 2+2                      // 6
+));                               // 7
+#line hidden
+}
+}".NormalizeLineEndings();
+
+            var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "page.razor.g.cs");
+            treeB.GetDiagnostics().Verify();
+
+            var actualLineMappings = GetLineMappings(treeB);
+            var expectedLineMappings = new[]
+            {
+                "(1,0)-(4,3) -> : (0,0)-(0,0)",
+                "(6,0)-(8,40),15 -> page.razor: (1,1)-(3,1)",
+                "(10,0)-(11,1) -> : (0,0)-(0,0)",
+            };
+            AssertEx.Equal(expectedLineMappings, actualLineMappings);
+
+            var textB = SourceText.From(sourceB);
+            var actualVisibility = textB.Lines.Select(line => treeB.GetLineVisibility(line.Start)).ToImmutableArray();
+            var expectedVisibility = new[]
+            {
+                LineVisibility.BeforeFirstLineDirective,
+                LineVisibility.Hidden,
+                LineVisibility.Hidden,
+                LineVisibility.Hidden,
+                LineVisibility.Hidden,
+                LineVisibility.Hidden,
+                LineVisibility.Visible,
+                LineVisibility.Visible,
+                LineVisibility.Visible,
+                LineVisibility.Visible,
+                LineVisibility.Hidden,
+                LineVisibility.Hidden,
+            };
+            AssertEx.Equal(expectedVisibility, actualVisibility);
+
+            var statements = GetStatementsAndExpressionBodies(treeB);
+            var actualTextSpans = statements.SelectAsArray(s => GetTextMapping(textA, treeB, s));
+            var expectedTextSpans = new[]
+            {
+                (@"_builder.Add(F(() => 1+1,       // 5...", @"[|F(() => 1+1,
+   () => 2+2
+)|]".NormalizeLineEndings()),
+                (@"1+1", @"[|1+1|]"),
+                (@"2+2", @"[|2+2|]"),
+            };
+            AssertEx.Equal(expectedTextSpans, actualTextSpans);
+        }
+
+        // 3. Razor: Single-line span
+        [WorkItem(4747, "https://github.com/dotnet/csharplang/issues/4747")]
+        [Fact]
+        public void LineSpanDirective_Example3()
+        {
+            string sourceA =
+@"@page ""/""
+Time: @DateTime.Now
+".NormalizeLineEndings();
+            var textA = SourceText.From(sourceA);
+
+            string sourceB =
+@"#line hidden
+class Page
+{
+void Render()
+{
+  _builder.Add(""Time:"");
+#line (2,8)-(2,19) 15 ""page.razor"" // spanof('DateTime.Now')
+  _builder.Add(DateTime.Now);
+#line hidden
+}
+}".NormalizeLineEndings();
+
+            var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "page.razor.g.cs");
+            treeB.GetDiagnostics().Verify();
+
+            var actualLineMappings = GetLineMappings(treeB);
+            var expectedLineMappings = new[]
+            {
+                "(1,0)-(5,26) -> : (0,0)-(0,0)",
+                "(7,0)-(7,31),14 -> page.razor: (1,7)-(1,19)",
+                "(9,0)-(10,1) -> : (0,0)-(0,0)",
+            };
+            AssertEx.Equal(expectedLineMappings, actualLineMappings);
+
+            var statements = GetStatementsAndExpressionBodies(treeB);
+            var actualTextSpans = statements.SelectAsArray(s => GetTextMapping(textA, treeB, s));
+            var expectedTextSpans = new[]
+            {
+                (@"_builder.Add(""Time:"");", @"[||]"),
+                (@"_builder.Add(DateTime.Now);", @"[|DateTime.Now|]"),
+            };
+            AssertEx.Equal(expectedTextSpans, actualTextSpans);
+        }
+
+        // 4. Razor: Multi-line span
+        [WorkItem(4747, "https://github.com/dotnet/csharplang/issues/4747")]
+        [Fact]
+        public void LineSpanDirective_Example4()
+        {
+            string sourceA =
+@"@page ""/""
+@JsonToHtml(@""
+{
+  """"key1"""": """"value1"""",
+  """"key2"""": """"value2""""
+}"")".NormalizeLineEndings();
+            var textA = SourceText.From(sourceA);
+
+            string sourceB =
+@"#line hidden
+class Page
+{
+void Render()
+{
+#line (2,2)-(6,3) 16 ""page.razor"" // spanof('JsonToHtml(...)')
+  _builder.Add(JsonToHtml(@""
+{
+  """"key1"""": """"value1"""",
+  """"key2"""": """"value2""""
+}""));
+#line hidden
+}
+}".NormalizeLineEndings();
+
+            var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "page.razor.g.cs");
+            treeB.GetDiagnostics().Verify();
+
+            var actualLineMappings = GetLineMappings(treeB);
+            var expectedLineMappings = new[]
+            {
+                "(1,0)-(4,3) -> : (0,0)-(0,0)",
+                "(6,0)-(10,7),15 -> page.razor: (1,1)-(5,3)",
+                "(12,0)-(13,1) -> : (0,0)-(0,0)",
+            };
+            AssertEx.Equal(expectedLineMappings, actualLineMappings);
+
+            var statements = GetStatementsAndExpressionBodies(treeB);
+            var actualTextSpans = statements.SelectAsArray(s => GetTextMapping(textA, treeB, s));
+            var expectedTextSpans = new[]
+            {
+                (@"_builder.Add(JsonToHtml(@""...", @"[|JsonToHtml(@""
+{
+  """"key1"""": """"value1"""",
+  """"key2"""": """"value2""""
+}"")|]".NormalizeLineEndings()),
+            };
+            AssertEx.Equal(expectedTextSpans, actualTextSpans);
+        }
+
+        // 5i. Razor: block constructs
+        [WorkItem(4747, "https://github.com/dotnet/csharplang/issues/4747")]
+        [Fact]
+        public void LineSpanDirective_Example5i()
+        {
+            string sourceA =
+@"@Html.Helper(() =>
+{
+    <p>Hello World</p>
+    @DateTime.Now
+})".NormalizeLineEndings();
+            var textA = SourceText.From(sourceA);
+
+            string sourceB =
+@"using System;
+class Page
+{
+    Builder _builder;
+    void Execute()
+    {
+#line (1, 2) - (5, 2) 22 ""a.razor"" // spanof('HtmlHelper(() => { ... })')
+        _builder.Add(Html.Helper(() =>
+#line 2 ""a.razor"" // lineof('{')
+        {
+#line (4, 6) - (4, 17) 26 ""a.razor"" // spanof('DateTime.Now')
+            _builder.Add(DateTime.Now);
+#line 5 ""a.razor"" // lineof('})')
+        })
+#line hidden
+        );
+    }
+}".NormalizeLineEndings();
+
+            var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "a.razor.g.cs");
+            treeB.GetDiagnostics().Verify();
+
+            var actualLineMappings = GetLineMappings(treeB);
+            var expectedLineMappings = new[]
+            {
+                "(0,0)-(5,7) -> : (0,0)-(5,7)",
+                "(7,0)-(7,40),21 -> a.razor: (0,1)-(4,2)",
+                "(9,0)-(9,11) -> a.razor: (1,0)-(1,11)",
+                "(11,0)-(11,41),25 -> a.razor: (3,5)-(3,17)",
+                "(13,0)-(13,12) -> a.razor: (4,0)-(4,12)",
+                "(15,0)-(17,1) -> : (0,0)-(0,0)",
+            };
+            AssertEx.Equal(expectedLineMappings, actualLineMappings);
+
+            var statements = GetStatementsAndExpressionBodies(treeB);
+            var actualTextSpans = statements.SelectAsArray(s => GetTextMapping(textA, treeB, s));
+            var expectedTextSpans = new[]
+            {
+                (@"_builder.Add(Html.Helper(() =>...", @"[|Html.Helper(() =>
+{
+    <p>Hello World</p>
+    @DateTime.Now
+})|]".NormalizeLineEndings()),
+                (@"_builder.Add(DateTime.Now);", @"[|DateTime.Now|]"),
+            };
+            AssertEx.Equal(expectedTextSpans, actualTextSpans);
+        }
+
+        private static ImmutableArray<SyntaxNode> GetStatementsAndExpressionBodies(SyntaxTree tree)
+        {
+            var builder = ArrayBuilder<SyntaxNode>.GetInstance();
+            foreach (var syntax in tree.GetRoot().DescendantNodesAndSelf())
+            {
+                switch (syntax)
+                {
+                    case ExpressionStatementSyntax:
+                        builder.Add(syntax);
+                        break;
+                    case ParenthesizedLambdaExpressionSyntax lambda:
+                        builder.AddIfNotNull(lambda.ExpressionBody);
+                        break;
+                    case SimpleLambdaExpressionSyntax lambda:
+                        builder.AddIfNotNull(lambda.ExpressionBody);
+                        break;
+                }
+            }
+            return builder.ToImmutableAndFree();
+        }
+
+        private static ImmutableArray<string> GetLineMappings(SyntaxTree tree)
+        {
+            var directives = tree.GetRoot().DescendantNodesAndSelf(descendIntoTrivia: true).OfType<DirectiveTriviaSyntax>();
+            foreach (var directive in directives)
+            {
+                Assert.NotEqual(SyntaxKind.None, directive.DirectiveNameToken.Kind());
+            }
+            return tree.GetLineMappings().Select(mapping => mapping.ToString()!).ToImmutableArray();
+        }
+
+        private static (string, string) GetTextMapping(SourceText mappedText, SyntaxTree unmappedText, SyntaxNode syntax)
+        {
+            return (getDescription(syntax), getMapping(mappedText, unmappedText, syntax));
+
+            static string getDescription(SyntaxNode syntax)
+            {
+                var description = syntax.ToString();
+                int index = description.IndexOfAny(new[] { '\r', '\n' });
+                return index < 0 ?
+                    description :
+                    description.Substring(0, index) + "...";
+            }
+
+            static string getMapping(SourceText mappedText, SyntaxTree unmappedText, SyntaxNode syntax)
+            {
+                var mappedLineAndPositionSpan = unmappedText.GetMappedLineSpanAndVisibility(syntax.Span, out _);
+                var span = getTextSpan(mappedText.Lines, mappedLineAndPositionSpan.Span);
+                return $"[|{mappedText.GetSubText(span)}|]";
+            }
+
+            static TextSpan getTextSpan(TextLineCollection lines, LinePositionSpan span)
+            {
+                return TextSpan.FromBounds(getTextPosition(lines, span.Start), getTextPosition(lines, span.End));
+            }
+
+            static int getTextPosition(TextLineCollection lines, LinePosition position)
+            {
+                if (position.Line < lines.Count)
+                {
+                    var line = lines[position.Line];
+                    return Math.Min(line.Start + position.Character, line.End);
+                }
+                return (lines.Count == 0) ? 0 : lines[^1].End;
+            }
+        }
+
+        [Fact]
+        public void Diagnostics()
+        {
+            var source =
+@"class Program
+{
+    static void Main()
+    {
+#line (3, 3) - (6, 6) 8 ""a.txt""
+        A();
+#line default
+        B();
+#line (1, 1) - (1, 100) ""b.txt""
+        C();
+    }
+}".NormalizeLineEndings();
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // b.txt(1,9): error CS0103: The name 'C' does not exist in the current context
+                //         C();
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "C").WithArguments("C").WithLocation(1, 9),
+                // a.txt(3,4): error CS0103: The name 'A' does not exist in the current context
+                //         A();
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "A").WithArguments("A").WithLocation(3, 4),
+                // (8,9): error CS0103: The name 'B' does not exist in the current context
+                //         B();
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "B").WithArguments("B").WithLocation(8, 9));
+        }
+
+        [Fact]
+        public void SequencePoints()
+        {
+            var source =
+@"class Program
+{
+    static void Main()
+    {
+#line (3, 3) - (6, 6) 8 ""a.txt""
+        A();
+#line default
+        B();
+#line (1, 1) - (1, 100) ""b.txt""
+        C();
+#line (2, 3) - (2, 4) 9 ""a.txt""
+        D();
+    }
+    static void A() { }
+    static void B() { }
+    static void C() { }
+    static void D() { }
+}".NormalizeLineEndings();
+            var verifier = CompileAndVerify(source, options: TestOptions.DebugDll);
+            verifier.VerifyIL("Program.Main", sequencePoints: "Program.Main", expectedIL:
+@"{
+  // Code size       26 (0x1a)
+  .maxstack  0
+ -IL_0000:  nop
+ -IL_0001:  call       ""void Program.A()""
+  IL_0006:  nop
+ -IL_0007:  call       ""void Program.B()""
+  IL_000c:  nop
+ -IL_000d:  call       ""void Program.C()""
+  IL_0012:  nop
+ -IL_0013:  call       ""void Program.D()""
+  IL_0018:  nop
+ -IL_0019:  ret
+}");
+            verifier.VerifyPdb("Program.Main", expectedPdb:
+@"<symbols>
+  <files>
+    <file id=""1"" name="""" language=""C#"" />
+    <file id=""2"" name=""a.txt"" language=""C#"" />
+    <file id=""3"" name=""b.txt"" language=""C#"" />
+  </files>
+  <methods>
+    <method containingType=""Program"" name=""Main"">
+      <customDebugInfo>
+        <using>
+          <namespace usingCount=""0"" />
+        </using>
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" startLine=""4"" startColumn=""5"" endLine=""4"" endColumn=""6"" document=""1"" />
+        <entry offset=""0x1"" startLine=""3"" startColumn=""4"" endLine=""3"" endColumn=""8"" document=""2"" />
+        <entry offset=""0x7"" startLine=""8"" startColumn=""9"" endLine=""8"" endColumn=""13"" document=""1"" />
+        <entry offset=""0xd"" startLine=""1"" startColumn=""9"" endLine=""1"" endColumn=""13"" document=""3"" />
+        <entry offset=""0x13"" startLine=""2"" startColumn=""3"" endLine=""2"" endColumn=""5"" document=""2"" />
+        <entry offset=""0x19"" startLine=""3"" startColumn=""5"" endLine=""3"" endColumn=""6"" document=""2"" />
+      </sequencePoints>
+    </method>
+  </methods>
+</symbols>
+");
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs
index 6cfbecbebd403..b480da073976c 100644
--- a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs
@@ -176,7 +176,7 @@ private static Syntax.InternalSyntax.RefExpressionSyntax GenerateRefExpression()
             => InternalSyntaxFactory.RefExpression(InternalSyntaxFactory.Token(SyntaxKind.RefKeyword), GenerateIdentifierName());
 
         private static Syntax.InternalSyntax.ParenthesizedLambdaExpressionSyntax GenerateParenthesizedLambdaExpression()
-            => InternalSyntaxFactory.ParenthesizedLambdaExpression(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), GenerateParameterList(), InternalSyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), null, null);
+            => InternalSyntaxFactory.ParenthesizedLambdaExpression(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), null, GenerateParameterList(), InternalSyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), null, null);
 
         private static Syntax.InternalSyntax.InitializerExpressionSyntax GenerateInitializerExpression()
             => InternalSyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, InternalSyntaxFactory.Token(SyntaxKind.OpenBraceToken), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList<Syntax.InternalSyntax.ExpressionSyntax>(), InternalSyntaxFactory.Token(SyntaxKind.CloseBraceToken));
@@ -533,10 +533,10 @@ private static Syntax.InternalSyntax.MethodDeclarationSyntax GenerateMethodDecla
             => InternalSyntaxFactory.MethodDeclaration(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), GenerateIdentifierName(), null, InternalSyntaxFactory.Identifier("Identifier"), null, GenerateParameterList(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.TypeParameterConstraintClauseSyntax>(), null, null, null);
 
         private static Syntax.InternalSyntax.OperatorDeclarationSyntax GenerateOperatorDeclaration()
-            => InternalSyntaxFactory.OperatorDeclaration(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), GenerateIdentifierName(), InternalSyntaxFactory.Token(SyntaxKind.OperatorKeyword), InternalSyntaxFactory.Token(SyntaxKind.PlusToken), GenerateParameterList(), null, null, null);
+            => InternalSyntaxFactory.OperatorDeclaration(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), GenerateIdentifierName(), null, InternalSyntaxFactory.Token(SyntaxKind.OperatorKeyword), InternalSyntaxFactory.Token(SyntaxKind.PlusToken), GenerateParameterList(), null, null, null);
 
         private static Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax GenerateConversionOperatorDeclaration()
-            => InternalSyntaxFactory.ConversionOperatorDeclaration(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), InternalSyntaxFactory.Token(SyntaxKind.ImplicitKeyword), InternalSyntaxFactory.Token(SyntaxKind.OperatorKeyword), GenerateIdentifierName(), GenerateParameterList(), null, null, null);
+            => InternalSyntaxFactory.ConversionOperatorDeclaration(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), InternalSyntaxFactory.Token(SyntaxKind.ImplicitKeyword), null, InternalSyntaxFactory.Token(SyntaxKind.OperatorKeyword), GenerateIdentifierName(), GenerateParameterList(), null, null, null);
 
         private static Syntax.InternalSyntax.ConstructorDeclarationSyntax GenerateConstructorDeclaration()
             => InternalSyntaxFactory.ConstructorDeclaration(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), InternalSyntaxFactory.Identifier("Identifier"), GenerateParameterList(), null, null, null, null);
@@ -688,6 +688,12 @@ private static Syntax.InternalSyntax.UndefDirectiveTriviaSyntax GenerateUndefDir
         private static Syntax.InternalSyntax.LineDirectiveTriviaSyntax GenerateLineDirectiveTrivia()
             => InternalSyntaxFactory.LineDirectiveTrivia(InternalSyntaxFactory.Token(SyntaxKind.HashToken), InternalSyntaxFactory.Token(SyntaxKind.LineKeyword), InternalSyntaxFactory.Literal(null, "1", 1, null), null, InternalSyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool());
 
+        private static Syntax.InternalSyntax.LineDirectivePositionSyntax GenerateLineDirectivePosition()
+            => InternalSyntaxFactory.LineDirectivePosition(InternalSyntaxFactory.Token(SyntaxKind.OpenParenToken), InternalSyntaxFactory.Literal(null, "1", 1, null), InternalSyntaxFactory.Token(SyntaxKind.CommaToken), InternalSyntaxFactory.Literal(null, "1", 1, null), InternalSyntaxFactory.Token(SyntaxKind.CloseParenToken));
+
+        private static Syntax.InternalSyntax.LineSpanDirectiveTriviaSyntax GenerateLineSpanDirectiveTrivia()
+            => InternalSyntaxFactory.LineSpanDirectiveTrivia(InternalSyntaxFactory.Token(SyntaxKind.HashToken), InternalSyntaxFactory.Token(SyntaxKind.LineKeyword), GenerateLineDirectivePosition(), InternalSyntaxFactory.Token(SyntaxKind.MinusToken), GenerateLineDirectivePosition(), null, InternalSyntaxFactory.Literal(null, "string", "string", null), InternalSyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool());
+
         private static Syntax.InternalSyntax.PragmaWarningDirectiveTriviaSyntax GeneratePragmaWarningDirectiveTrivia()
             => InternalSyntaxFactory.PragmaWarningDirectiveTrivia(InternalSyntaxFactory.Token(SyntaxKind.HashToken), InternalSyntaxFactory.Token(SyntaxKind.PragmaKeyword), InternalSyntaxFactory.Token(SyntaxKind.WarningKeyword), InternalSyntaxFactory.Token(SyntaxKind.DisableKeyword), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList<Syntax.InternalSyntax.ExpressionSyntax>(), InternalSyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool());
 
@@ -1359,6 +1365,7 @@ public void TestParenthesizedLambdaExpressionFactoryAndProperties()
 
             Assert.Equal(default, node.AttributeLists);
             Assert.Equal(default, node.Modifiers);
+            Assert.Null(node.ReturnType);
             Assert.NotNull(node.ParameterList);
             Assert.Equal(SyntaxKind.EqualsGreaterThanToken, node.ArrowToken.Kind);
             Assert.Null(node.Block);
@@ -2909,6 +2916,7 @@ public void TestOperatorDeclarationFactoryAndProperties()
             Assert.Equal(default, node.AttributeLists);
             Assert.Equal(default, node.Modifiers);
             Assert.NotNull(node.ReturnType);
+            Assert.Null(node.ExplicitInterfaceSpecifier);
             Assert.Equal(SyntaxKind.OperatorKeyword, node.OperatorKeyword.Kind);
             Assert.Equal(SyntaxKind.PlusToken, node.OperatorToken.Kind);
             Assert.NotNull(node.ParameterList);
@@ -2927,6 +2935,7 @@ public void TestConversionOperatorDeclarationFactoryAndProperties()
             Assert.Equal(default, node.AttributeLists);
             Assert.Equal(default, node.Modifiers);
             Assert.Equal(SyntaxKind.ImplicitKeyword, node.ImplicitOrExplicitKeyword.Kind);
+            Assert.Null(node.ExplicitInterfaceSpecifier);
             Assert.Equal(SyntaxKind.OperatorKeyword, node.OperatorKeyword.Kind);
             Assert.NotNull(node.Type);
             Assert.NotNull(node.ParameterList);
@@ -3589,6 +3598,38 @@ public void TestLineDirectiveTriviaFactoryAndProperties()
             AttachAndCheckDiagnostics(node);
         }
 
+        [Fact]
+        public void TestLineDirectivePositionFactoryAndProperties()
+        {
+            var node = GenerateLineDirectivePosition();
+
+            Assert.Equal(SyntaxKind.OpenParenToken, node.OpenParenToken.Kind);
+            Assert.Equal(SyntaxKind.NumericLiteralToken, node.Line.Kind);
+            Assert.Equal(SyntaxKind.CommaToken, node.CommaToken.Kind);
+            Assert.Equal(SyntaxKind.NumericLiteralToken, node.Character.Kind);
+            Assert.Equal(SyntaxKind.CloseParenToken, node.CloseParenToken.Kind);
+
+            AttachAndCheckDiagnostics(node);
+        }
+
+        [Fact]
+        public void TestLineSpanDirectiveTriviaFactoryAndProperties()
+        {
+            var node = GenerateLineSpanDirectiveTrivia();
+
+            Assert.Equal(SyntaxKind.HashToken, node.HashToken.Kind);
+            Assert.Equal(SyntaxKind.LineKeyword, node.LineKeyword.Kind);
+            Assert.NotNull(node.Start);
+            Assert.Equal(SyntaxKind.MinusToken, node.MinusToken.Kind);
+            Assert.NotNull(node.End);
+            Assert.Null(node.CharacterOffset);
+            Assert.Equal(SyntaxKind.StringLiteralToken, node.File.Kind);
+            Assert.Equal(SyntaxKind.EndOfDirectiveToken, node.EndOfDirectiveToken.Kind);
+            Assert.Equal(new bool(), node.IsActive);
+
+            AttachAndCheckDiagnostics(node);
+        }
+
         [Fact]
         public void TestPragmaWarningDirectiveTriviaFactoryAndProperties()
         {
@@ -9556,6 +9597,58 @@ public void TestLineDirectiveTriviaIdentityRewriter()
             Assert.Same(oldNode, newNode);
         }
 
+        [Fact]
+        public void TestLineDirectivePositionTokenDeleteRewriter()
+        {
+            var oldNode = GenerateLineDirectivePosition();
+            var rewriter = new TokenDeleteRewriter();
+            var newNode = rewriter.Visit(oldNode);
+
+            if(!oldNode.IsMissing)
+            {
+                Assert.NotEqual(oldNode, newNode);
+            }
+
+            Assert.NotNull(newNode);
+            Assert.True(newNode.IsMissing, "No tokens => missing");
+        }
+
+        [Fact]
+        public void TestLineDirectivePositionIdentityRewriter()
+        {
+            var oldNode = GenerateLineDirectivePosition();
+            var rewriter = new IdentityRewriter();
+            var newNode = rewriter.Visit(oldNode);
+
+            Assert.Same(oldNode, newNode);
+        }
+
+        [Fact]
+        public void TestLineSpanDirectiveTriviaTokenDeleteRewriter()
+        {
+            var oldNode = GenerateLineSpanDirectiveTrivia();
+            var rewriter = new TokenDeleteRewriter();
+            var newNode = rewriter.Visit(oldNode);
+
+            if(!oldNode.IsMissing)
+            {
+                Assert.NotEqual(oldNode, newNode);
+            }
+
+            Assert.NotNull(newNode);
+            Assert.True(newNode.IsMissing, "No tokens => missing");
+        }
+
+        [Fact]
+        public void TestLineSpanDirectiveTriviaIdentityRewriter()
+        {
+            var oldNode = GenerateLineSpanDirectiveTrivia();
+            var rewriter = new IdentityRewriter();
+            var newNode = rewriter.Visit(oldNode);
+
+            Assert.Same(oldNode, newNode);
+        }
+
         [Fact]
         public void TestPragmaWarningDirectiveTriviaTokenDeleteRewriter()
         {
@@ -9883,7 +9976,7 @@ private static RefExpressionSyntax GenerateRefExpression()
             => SyntaxFactory.RefExpression(SyntaxFactory.Token(SyntaxKind.RefKeyword), GenerateIdentifierName());
 
         private static ParenthesizedLambdaExpressionSyntax GenerateParenthesizedLambdaExpression()
-            => SyntaxFactory.ParenthesizedLambdaExpression(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateParameterList(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default(BlockSyntax), default(ExpressionSyntax));
+            => SyntaxFactory.ParenthesizedLambdaExpression(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax), GenerateParameterList(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default(BlockSyntax), default(ExpressionSyntax));
 
         private static InitializerExpressionSyntax GenerateInitializerExpression()
             => SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken));
@@ -10240,10 +10333,10 @@ private static MethodDeclarationSyntax GenerateMethodDeclaration()
             => SyntaxFactory.MethodDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), GenerateParameterList(), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken));
 
         private static OperatorDeclarationSyntax GenerateOperatorDeclaration()
-            => SyntaxFactory.OperatorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateParameterList(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken));
+            => SyntaxFactory.OperatorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateParameterList(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken));
 
         private static ConversionOperatorDeclarationSyntax GenerateConversionOperatorDeclaration()
-            => SyntaxFactory.ConversionOperatorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.ImplicitKeyword), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), GenerateIdentifierName(), GenerateParameterList(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken));
+            => SyntaxFactory.ConversionOperatorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.ImplicitKeyword), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), GenerateIdentifierName(), GenerateParameterList(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken));
 
         private static ConstructorDeclarationSyntax GenerateConstructorDeclaration()
             => SyntaxFactory.ConstructorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Identifier("Identifier"), GenerateParameterList(), default(ConstructorInitializerSyntax), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken));
@@ -10395,6 +10488,12 @@ private static UndefDirectiveTriviaSyntax GenerateUndefDirectiveTrivia()
         private static LineDirectiveTriviaSyntax GenerateLineDirectiveTrivia()
             => SyntaxFactory.LineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), SyntaxFactory.Literal("1", 1), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool());
 
+        private static LineDirectivePositionSyntax GenerateLineDirectivePosition()
+            => SyntaxFactory.LineDirectivePosition(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Literal("1", 1), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Literal("1", 1), SyntaxFactory.Token(SyntaxKind.CloseParenToken));
+
+        private static LineSpanDirectiveTriviaSyntax GenerateLineSpanDirectiveTrivia()
+            => SyntaxFactory.LineSpanDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), GenerateLineDirectivePosition(), SyntaxFactory.Token(SyntaxKind.MinusToken), GenerateLineDirectivePosition(), default(SyntaxToken), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool());
+
         private static PragmaWarningDirectiveTriviaSyntax GeneratePragmaWarningDirectiveTrivia()
             => SyntaxFactory.PragmaWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.PragmaKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), SyntaxFactory.Token(SyntaxKind.DisableKeyword), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool());
 
@@ -11066,11 +11165,12 @@ public void TestParenthesizedLambdaExpressionFactoryAndProperties()
 
             Assert.Equal(default, node.AttributeLists);
             Assert.Equal(default, node.Modifiers);
+            Assert.Null(node.ReturnType);
             Assert.NotNull(node.ParameterList);
             Assert.Equal(SyntaxKind.EqualsGreaterThanToken, node.ArrowToken.Kind());
             Assert.Null(node.Block);
             Assert.Null(node.ExpressionBody);
-            var newNode = node.WithAttributeLists(node.AttributeLists).WithModifiers(node.Modifiers).WithParameterList(node.ParameterList).WithArrowToken(node.ArrowToken).WithBlock(node.Block).WithExpressionBody(node.ExpressionBody);
+            var newNode = node.WithAttributeLists(node.AttributeLists).WithModifiers(node.Modifiers).WithReturnType(node.ReturnType).WithParameterList(node.ParameterList).WithArrowToken(node.ArrowToken).WithBlock(node.Block).WithExpressionBody(node.ExpressionBody);
             Assert.Equal(node, newNode);
         }
 
@@ -12616,13 +12716,14 @@ public void TestOperatorDeclarationFactoryAndProperties()
             Assert.Equal(default, node.AttributeLists);
             Assert.Equal(default, node.Modifiers);
             Assert.NotNull(node.ReturnType);
+            Assert.Null(node.ExplicitInterfaceSpecifier);
             Assert.Equal(SyntaxKind.OperatorKeyword, node.OperatorKeyword.Kind());
             Assert.Equal(SyntaxKind.PlusToken, node.OperatorToken.Kind());
             Assert.NotNull(node.ParameterList);
             Assert.Null(node.Body);
             Assert.Null(node.ExpressionBody);
             Assert.Equal(SyntaxKind.None, node.SemicolonToken.Kind());
-            var newNode = node.WithAttributeLists(node.AttributeLists).WithModifiers(node.Modifiers).WithReturnType(node.ReturnType).WithOperatorKeyword(node.OperatorKeyword).WithOperatorToken(node.OperatorToken).WithParameterList(node.ParameterList).WithBody(node.Body).WithExpressionBody(node.ExpressionBody).WithSemicolonToken(node.SemicolonToken);
+            var newNode = node.WithAttributeLists(node.AttributeLists).WithModifiers(node.Modifiers).WithReturnType(node.ReturnType).WithExplicitInterfaceSpecifier(node.ExplicitInterfaceSpecifier).WithOperatorKeyword(node.OperatorKeyword).WithOperatorToken(node.OperatorToken).WithParameterList(node.ParameterList).WithBody(node.Body).WithExpressionBody(node.ExpressionBody).WithSemicolonToken(node.SemicolonToken);
             Assert.Equal(node, newNode);
         }
 
@@ -12634,13 +12735,14 @@ public void TestConversionOperatorDeclarationFactoryAndProperties()
             Assert.Equal(default, node.AttributeLists);
             Assert.Equal(default, node.Modifiers);
             Assert.Equal(SyntaxKind.ImplicitKeyword, node.ImplicitOrExplicitKeyword.Kind());
+            Assert.Null(node.ExplicitInterfaceSpecifier);
             Assert.Equal(SyntaxKind.OperatorKeyword, node.OperatorKeyword.Kind());
             Assert.NotNull(node.Type);
             Assert.NotNull(node.ParameterList);
             Assert.Null(node.Body);
             Assert.Null(node.ExpressionBody);
             Assert.Equal(SyntaxKind.None, node.SemicolonToken.Kind());
-            var newNode = node.WithAttributeLists(node.AttributeLists).WithModifiers(node.Modifiers).WithImplicitOrExplicitKeyword(node.ImplicitOrExplicitKeyword).WithOperatorKeyword(node.OperatorKeyword).WithType(node.Type).WithParameterList(node.ParameterList).WithBody(node.Body).WithExpressionBody(node.ExpressionBody).WithSemicolonToken(node.SemicolonToken);
+            var newNode = node.WithAttributeLists(node.AttributeLists).WithModifiers(node.Modifiers).WithImplicitOrExplicitKeyword(node.ImplicitOrExplicitKeyword).WithExplicitInterfaceSpecifier(node.ExplicitInterfaceSpecifier).WithOperatorKeyword(node.OperatorKeyword).WithType(node.Type).WithParameterList(node.ParameterList).WithBody(node.Body).WithExpressionBody(node.ExpressionBody).WithSemicolonToken(node.SemicolonToken);
             Assert.Equal(node, newNode);
         }
 
@@ -13296,6 +13398,38 @@ public void TestLineDirectiveTriviaFactoryAndProperties()
             Assert.Equal(node, newNode);
         }
 
+        [Fact]
+        public void TestLineDirectivePositionFactoryAndProperties()
+        {
+            var node = GenerateLineDirectivePosition();
+
+            Assert.Equal(SyntaxKind.OpenParenToken, node.OpenParenToken.Kind());
+            Assert.Equal(SyntaxKind.NumericLiteralToken, node.Line.Kind());
+            Assert.Equal(SyntaxKind.CommaToken, node.CommaToken.Kind());
+            Assert.Equal(SyntaxKind.NumericLiteralToken, node.Character.Kind());
+            Assert.Equal(SyntaxKind.CloseParenToken, node.CloseParenToken.Kind());
+            var newNode = node.WithOpenParenToken(node.OpenParenToken).WithLine(node.Line).WithCommaToken(node.CommaToken).WithCharacter(node.Character).WithCloseParenToken(node.CloseParenToken);
+            Assert.Equal(node, newNode);
+        }
+
+        [Fact]
+        public void TestLineSpanDirectiveTriviaFactoryAndProperties()
+        {
+            var node = GenerateLineSpanDirectiveTrivia();
+
+            Assert.Equal(SyntaxKind.HashToken, node.HashToken.Kind());
+            Assert.Equal(SyntaxKind.LineKeyword, node.LineKeyword.Kind());
+            Assert.NotNull(node.Start);
+            Assert.Equal(SyntaxKind.MinusToken, node.MinusToken.Kind());
+            Assert.NotNull(node.End);
+            Assert.Equal(SyntaxKind.None, node.CharacterOffset.Kind());
+            Assert.Equal(SyntaxKind.StringLiteralToken, node.File.Kind());
+            Assert.Equal(SyntaxKind.EndOfDirectiveToken, node.EndOfDirectiveToken.Kind());
+            Assert.Equal(new bool(), node.IsActive);
+            var newNode = node.WithHashToken(node.HashToken).WithLineKeyword(node.LineKeyword).WithStart(node.Start).WithMinusToken(node.MinusToken).WithEnd(node.End).WithCharacterOffset(node.CharacterOffset).WithFile(node.File).WithEndOfDirectiveToken(node.EndOfDirectiveToken).WithIsActive(node.IsActive);
+            Assert.Equal(node, newNode);
+        }
+
         [Fact]
         public void TestPragmaWarningDirectiveTriviaFactoryAndProperties()
         {
@@ -19263,6 +19397,58 @@ public void TestLineDirectiveTriviaIdentityRewriter()
             Assert.Same(oldNode, newNode);
         }
 
+        [Fact]
+        public void TestLineDirectivePositionTokenDeleteRewriter()
+        {
+            var oldNode = GenerateLineDirectivePosition();
+            var rewriter = new TokenDeleteRewriter();
+            var newNode = rewriter.Visit(oldNode);
+
+            if(!oldNode.IsMissing)
+            {
+                Assert.NotEqual(oldNode, newNode);
+            }
+
+            Assert.NotNull(newNode);
+            Assert.True(newNode.IsMissing, "No tokens => missing");
+        }
+
+        [Fact]
+        public void TestLineDirectivePositionIdentityRewriter()
+        {
+            var oldNode = GenerateLineDirectivePosition();
+            var rewriter = new IdentityRewriter();
+            var newNode = rewriter.Visit(oldNode);
+
+            Assert.Same(oldNode, newNode);
+        }
+
+        [Fact]
+        public void TestLineSpanDirectiveTriviaTokenDeleteRewriter()
+        {
+            var oldNode = GenerateLineSpanDirectiveTrivia();
+            var rewriter = new TokenDeleteRewriter();
+            var newNode = rewriter.Visit(oldNode);
+
+            if(!oldNode.IsMissing)
+            {
+                Assert.NotEqual(oldNode, newNode);
+            }
+
+            Assert.NotNull(newNode);
+            Assert.True(newNode.IsMissing, "No tokens => missing");
+        }
+
+        [Fact]
+        public void TestLineSpanDirectiveTriviaIdentityRewriter()
+        {
+            var oldNode = GenerateLineSpanDirectiveTrivia();
+            var rewriter = new IdentityRewriter();
+            var newNode = rewriter.Visit(oldNode);
+
+            Assert.Same(oldNode, newNode);
+        }
+
         [Fact]
         public void TestPragmaWarningDirectiveTriviaTokenDeleteRewriter()
         {
diff --git a/src/Compilers/CSharp/Test/Syntax/LexicalAndXml/PreprocessorTests.cs b/src/Compilers/CSharp/Test/Syntax/LexicalAndXml/PreprocessorTests.cs
index d49b5b3e3c398..559aef0d9e5d7 100644
--- a/src/Compilers/CSharp/Test/Syntax/LexicalAndXml/PreprocessorTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/LexicalAndXml/PreprocessorTests.cs
@@ -3037,9 +3037,9 @@ private void CheckDiagnosticStringFileName(string compilationFileName, string li
         [Theory]
         [InlineData(LanguageVersion.CSharp4, "4")]
         [InlineData(LanguageVersion.CSharp9, "9.0")]
-        [InlineData(LanguageVersion.Latest, "latest (9.0)")]
-        [InlineData(LanguageVersion.LatestMajor, "latestmajor (9.0)")]
-        [InlineData(LanguageVersion.Default, "default (9.0)")]
+        [InlineData(LanguageVersion.Latest, "latest (10.0)")]
+        [InlineData(LanguageVersion.LatestMajor, "latestmajor (10.0)")]
+        [InlineData(LanguageVersion.Default, "default (10.0)")]
         [InlineData(LanguageVersion.Preview, "preview")]
         public void TestErrorWithVersion(LanguageVersion version, string expectedLanguageVersion)
         {
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/DeconstructionTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/DeconstructionTests.cs
index 5abc85ef9d624..c167d2bc46bc0 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/DeconstructionTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/DeconstructionTests.cs
@@ -2128,12 +2128,12 @@ struct ValueTuple<T1, T2>
     }
 }";
             CreateCompilation(source, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
-                    // (7,9): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                    //         (int x1, x2) = (1, 2);
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "(int x1, x2) = (1, 2)", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(7, 9),
-                    // (8,9): error CS8652: The feature 'Mixed declarations and expressions in deconstruction' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                    //         (x3, int x4) = (1, 2);
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "(x3, int x4) = (1, 2)", isSuppressed: false).WithArguments("Mixed declarations and expressions in deconstruction").WithLocation(8, 9));
+                // (7,9): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //         (int x1, x2) = (1, 2);
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(int x1, x2) = (1, 2)").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(7, 9),
+                // (8,9): error CS8773: Feature 'Mixed declarations and expressions in deconstruction' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //         (x3, int x4) = (1, 2);
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "(x3, int x4) = (1, 2)").WithArguments("Mixed declarations and expressions in deconstruction", "10.0").WithLocation(8, 9));
         }
 
         [Fact, WorkItem(12803, "https://github.com/dotnet/roslyn/issues/12803")]
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
index 49f8196a6339a..de2bf0dd18253 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
@@ -37,7 +37,7 @@ void Goo() {
                 N(SyntaxKind.ClassDeclaration);
                 {
                     N(SyntaxKind.ClassKeyword);
-                    N(SyntaxKind.IdentifierToken);
+                    N(SyntaxKind.IdentifierToken, "C");
                     N(SyntaxKind.OpenBraceToken);
                     N(SyntaxKind.MethodDeclaration);
                     {
@@ -45,7 +45,7 @@ void Goo() {
                         {
                             N(SyntaxKind.VoidKeyword);
                         }
-                        N(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.IdentifierToken, "Goo");
                         N(SyntaxKind.ParameterList);
                         {
                             N(SyntaxKind.OpenParenToken);
@@ -62,12 +62,12 @@ void Goo() {
                                     {
                                         N(SyntaxKind.IdentifierName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "System");
                                         }
                                         N(SyntaxKind.DotToken);
                                         N(SyntaxKind.GenericName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "Func");
                                             N(SyntaxKind.TypeArgumentList);
                                             {
                                                 N(SyntaxKind.LessThanToken);
@@ -86,31 +86,18 @@ void Goo() {
                                     }
                                     N(SyntaxKind.VariableDeclarator);
                                     {
-                                        N(SyntaxKind.IdentifierToken);
+                                        N(SyntaxKind.IdentifierToken, "f");
                                         N(SyntaxKind.EqualsValueClause);
                                         {
                                             N(SyntaxKind.EqualsToken);
-                                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                                            N(SyntaxKind.ParenthesizedExpression);
                                             {
-                                                N(SyntaxKind.ParameterList);
-                                                {
-                                                    N(SyntaxKind.OpenParenToken);
-                                                    N(SyntaxKind.Parameter);
-                                                    {
-                                                        N(SyntaxKind.OutKeyword);
-                                                        M(SyntaxKind.IdentifierName); // parameter type
-                                                        {
-                                                            M(SyntaxKind.IdentifierToken);
-                                                        }
-                                                        M(SyntaxKind.IdentifierToken); // parameter name
-                                                    }
-                                                    M(SyntaxKind.CloseParenToken);
-                                                }
-                                                M(SyntaxKind.EqualsGreaterThanToken);
-                                                M(SyntaxKind.IdentifierName); // lambda body
+                                                N(SyntaxKind.OpenParenToken);
+                                                M(SyntaxKind.IdentifierName);
                                                 {
                                                     M(SyntaxKind.IdentifierToken);
                                                 }
+                                                M(SyntaxKind.CloseParenToken);
                                             }
                                         }
                                     }
@@ -124,6 +111,7 @@ void Goo() {
                 }
                 N(SyntaxKind.EndOfFileToken);
             }
+            EOF();
         }
 
         [Fact]
@@ -139,7 +127,7 @@ void Goo() {
                 N(SyntaxKind.ClassDeclaration);
                 {
                     N(SyntaxKind.ClassKeyword);
-                    N(SyntaxKind.IdentifierToken);
+                    N(SyntaxKind.IdentifierToken, "C");
                     N(SyntaxKind.OpenBraceToken);
                     N(SyntaxKind.MethodDeclaration);
                     {
@@ -147,7 +135,7 @@ void Goo() {
                         {
                             N(SyntaxKind.VoidKeyword);
                         }
-                        N(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.IdentifierToken, "Goo");
                         N(SyntaxKind.ParameterList);
                         {
                             N(SyntaxKind.OpenParenToken);
@@ -164,12 +152,12 @@ void Goo() {
                                     {
                                         N(SyntaxKind.IdentifierName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "System");
                                         }
                                         N(SyntaxKind.DotToken);
                                         N(SyntaxKind.GenericName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "Func");
                                             N(SyntaxKind.TypeArgumentList);
                                             {
                                                 N(SyntaxKind.LessThanToken);
@@ -188,37 +176,32 @@ void Goo() {
                                     }
                                     N(SyntaxKind.VariableDeclarator);
                                     {
-                                        N(SyntaxKind.IdentifierToken);
+                                        N(SyntaxKind.IdentifierToken, "f");
                                         N(SyntaxKind.EqualsValueClause);
                                         {
                                             N(SyntaxKind.EqualsToken);
-                                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                                            N(SyntaxKind.ParenthesizedExpression);
                                             {
-                                                N(SyntaxKind.ParameterList);
-                                                {
-                                                    N(SyntaxKind.OpenParenToken);
-                                                    N(SyntaxKind.Parameter);
-                                                    {
-                                                        N(SyntaxKind.OutKeyword);
-                                                        N(SyntaxKind.IdentifierName); // parameter type
-                                                        {
-                                                            N(SyntaxKind.IdentifierToken);
-                                                        }
-                                                        M(SyntaxKind.IdentifierToken); // parameter name
-                                                    }
-                                                    M(SyntaxKind.CloseParenToken);
-                                                }
-                                                M(SyntaxKind.EqualsGreaterThanToken);
-                                                M(SyntaxKind.IdentifierName); // lambda body
+                                                N(SyntaxKind.OpenParenToken);
+                                                M(SyntaxKind.IdentifierName);
                                                 {
                                                     M(SyntaxKind.IdentifierToken);
                                                 }
+                                                M(SyntaxKind.CloseParenToken);
                                             }
                                         }
                                     }
                                 }
                                 M(SyntaxKind.SemicolonToken);
                             }
+                            N(SyntaxKind.ExpressionStatement);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "C");
+                                }
+                                M(SyntaxKind.SemicolonToken);
+                            }
                             M(SyntaxKind.CloseBraceToken);
                         }
                     }
@@ -226,6 +209,7 @@ void Goo() {
                 }
                 N(SyntaxKind.EndOfFileToken);
             }
+            EOF();
         }
 
         [Fact]
@@ -241,7 +225,7 @@ void Goo() {
                 N(SyntaxKind.ClassDeclaration);
                 {
                     N(SyntaxKind.ClassKeyword);
-                    N(SyntaxKind.IdentifierToken);
+                    N(SyntaxKind.IdentifierToken, "C");
                     N(SyntaxKind.OpenBraceToken);
                     N(SyntaxKind.MethodDeclaration);
                     {
@@ -249,7 +233,7 @@ void Goo() {
                         {
                             N(SyntaxKind.VoidKeyword);
                         }
-                        N(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.IdentifierToken, "Goo");
                         N(SyntaxKind.ParameterList);
                         {
                             N(SyntaxKind.OpenParenToken);
@@ -266,12 +250,12 @@ void Goo() {
                                     {
                                         N(SyntaxKind.IdentifierName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "System");
                                         }
                                         N(SyntaxKind.DotToken);
                                         N(SyntaxKind.GenericName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "Func");
                                             N(SyntaxKind.TypeArgumentList);
                                             {
                                                 N(SyntaxKind.LessThanToken);
@@ -290,37 +274,39 @@ void Goo() {
                                     }
                                     N(SyntaxKind.VariableDeclarator);
                                     {
-                                        N(SyntaxKind.IdentifierToken);
+                                        N(SyntaxKind.IdentifierToken, "f");
                                         N(SyntaxKind.EqualsValueClause);
                                         {
                                             N(SyntaxKind.EqualsToken);
-                                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                                            N(SyntaxKind.ParenthesizedExpression);
                                             {
-                                                N(SyntaxKind.ParameterList);
-                                                {
-                                                    N(SyntaxKind.OpenParenToken);
-                                                    N(SyntaxKind.Parameter);
-                                                    {
-                                                        N(SyntaxKind.OutKeyword);
-                                                        N(SyntaxKind.IdentifierName); // parameter type
-                                                        {
-                                                            N(SyntaxKind.IdentifierToken);
-                                                        }
-                                                        N(SyntaxKind.IdentifierToken); // parameter name
-                                                    }
-                                                    M(SyntaxKind.CloseParenToken);
-                                                }
-                                                M(SyntaxKind.EqualsGreaterThanToken);
-                                                M(SyntaxKind.IdentifierName); // lambda body
+                                                N(SyntaxKind.OpenParenToken);
+                                                M(SyntaxKind.IdentifierName);
                                                 {
                                                     M(SyntaxKind.IdentifierToken);
                                                 }
+                                                M(SyntaxKind.CloseParenToken);
                                             }
                                         }
                                     }
                                 }
                                 M(SyntaxKind.SemicolonToken);
                             }
+                            N(SyntaxKind.LocalDeclarationStatement);
+                            {
+                                N(SyntaxKind.VariableDeclaration);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "C");
+                                    }
+                                    N(SyntaxKind.VariableDeclarator);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "c");
+                                    }
+                                }
+                                M(SyntaxKind.SemicolonToken);
+                            }
                             M(SyntaxKind.CloseBraceToken);
                         }
                     }
@@ -328,6 +314,7 @@ void Goo() {
                 }
                 N(SyntaxKind.EndOfFileToken);
             }
+            EOF();
         }
 
         [Fact]
@@ -343,7 +330,7 @@ void Goo() {
                 N(SyntaxKind.ClassDeclaration);
                 {
                     N(SyntaxKind.ClassKeyword);
-                    N(SyntaxKind.IdentifierToken);
+                    N(SyntaxKind.IdentifierToken, "C");
                     N(SyntaxKind.OpenBraceToken);
                     N(SyntaxKind.MethodDeclaration);
                     {
@@ -351,7 +338,7 @@ void Goo() {
                         {
                             N(SyntaxKind.VoidKeyword);
                         }
-                        N(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.IdentifierToken, "Goo");
                         N(SyntaxKind.ParameterList);
                         {
                             N(SyntaxKind.OpenParenToken);
@@ -368,12 +355,12 @@ void Goo() {
                                     {
                                         N(SyntaxKind.IdentifierName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "System");
                                         }
                                         N(SyntaxKind.DotToken);
                                         N(SyntaxKind.GenericName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "Func");
                                             N(SyntaxKind.TypeArgumentList);
                                             {
                                                 N(SyntaxKind.LessThanToken);
@@ -392,37 +379,39 @@ void Goo() {
                                     }
                                     N(SyntaxKind.VariableDeclarator);
                                     {
-                                        N(SyntaxKind.IdentifierToken);
+                                        N(SyntaxKind.IdentifierToken, "f");
                                         N(SyntaxKind.EqualsValueClause);
                                         {
                                             N(SyntaxKind.EqualsToken);
-                                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                                            N(SyntaxKind.ParenthesizedExpression);
                                             {
-                                                N(SyntaxKind.ParameterList);
-                                                {
-                                                    N(SyntaxKind.OpenParenToken);
-                                                    N(SyntaxKind.Parameter);
-                                                    {
-                                                        N(SyntaxKind.OutKeyword);
-                                                        N(SyntaxKind.IdentifierName); // parameter type
-                                                        {
-                                                            N(SyntaxKind.IdentifierToken);
-                                                        }
-                                                        N(SyntaxKind.IdentifierToken); // parameter name
-                                                    }
-                                                    M(SyntaxKind.CloseParenToken);
-                                                }
-                                                M(SyntaxKind.EqualsGreaterThanToken);
-                                                M(SyntaxKind.IdentifierName); // lambda body
+                                                N(SyntaxKind.OpenParenToken);
+                                                M(SyntaxKind.IdentifierName);
                                                 {
                                                     M(SyntaxKind.IdentifierToken);
                                                 }
+                                                M(SyntaxKind.CloseParenToken);
                                             }
                                         }
                                     }
                                 }
                                 M(SyntaxKind.SemicolonToken);
                             }
+                            N(SyntaxKind.LocalDeclarationStatement);
+                            {
+                                N(SyntaxKind.VariableDeclaration);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "C");
+                                    }
+                                    N(SyntaxKind.VariableDeclarator);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "c");
+                                    }
+                                }
+                                M(SyntaxKind.SemicolonToken);
+                            }
                             M(SyntaxKind.CloseBraceToken);
                         }
                     }
@@ -430,6 +419,7 @@ void Goo() {
                 }
                 N(SyntaxKind.EndOfFileToken);
             }
+            EOF();
         }
 
         [Fact]
@@ -445,7 +435,7 @@ void Goo() {
                 N(SyntaxKind.ClassDeclaration);
                 {
                     N(SyntaxKind.ClassKeyword);
-                    N(SyntaxKind.IdentifierToken);
+                    N(SyntaxKind.IdentifierToken, "C");
                     N(SyntaxKind.OpenBraceToken);
                     N(SyntaxKind.MethodDeclaration);
                     {
@@ -453,7 +443,7 @@ void Goo() {
                         {
                             N(SyntaxKind.VoidKeyword);
                         }
-                        N(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.IdentifierToken, "Goo");
                         N(SyntaxKind.ParameterList);
                         {
                             N(SyntaxKind.OpenParenToken);
@@ -470,12 +460,12 @@ void Goo() {
                                     {
                                         N(SyntaxKind.IdentifierName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "System");
                                         }
                                         N(SyntaxKind.DotToken);
                                         N(SyntaxKind.GenericName);
                                         {
-                                            N(SyntaxKind.IdentifierToken);
+                                            N(SyntaxKind.IdentifierToken, "Func");
                                             N(SyntaxKind.TypeArgumentList);
                                             {
                                                 N(SyntaxKind.LessThanToken);
@@ -494,42 +484,44 @@ void Goo() {
                                     }
                                     N(SyntaxKind.VariableDeclarator);
                                     {
-                                        N(SyntaxKind.IdentifierToken);
+                                        N(SyntaxKind.IdentifierToken, "f");
                                         N(SyntaxKind.EqualsValueClause);
                                         {
                                             N(SyntaxKind.EqualsToken);
-                                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                                            N(SyntaxKind.ParenthesizedExpression);
                                             {
-                                                N(SyntaxKind.ParameterList);
-                                                {
-                                                    N(SyntaxKind.OpenParenToken);
-                                                    N(SyntaxKind.Parameter);
-                                                    {
-                                                        N(SyntaxKind.OutKeyword);
-                                                        N(SyntaxKind.IdentifierName);
-                                                        {
-                                                            N(SyntaxKind.IdentifierToken);
-                                                        }
-                                                        N(SyntaxKind.IdentifierToken);
-                                                    }
-                                                    N(SyntaxKind.CommaToken);
-                                                    M(SyntaxKind.Parameter);
-                                                    {
-                                                        M(SyntaxKind.IdentifierToken);
-                                                    }
-                                                    M(SyntaxKind.CloseParenToken);
-                                                }
-                                                M(SyntaxKind.EqualsGreaterThanToken);
+                                                N(SyntaxKind.OpenParenToken);
                                                 M(SyntaxKind.IdentifierName);
                                                 {
                                                     M(SyntaxKind.IdentifierToken);
                                                 }
+                                                M(SyntaxKind.CloseParenToken);
                                             }
                                         }
                                     }
                                 }
                                 M(SyntaxKind.SemicolonToken);
                             }
+                            N(SyntaxKind.LocalDeclarationStatement);
+                            {
+                                N(SyntaxKind.VariableDeclaration);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "C");
+                                    }
+                                    N(SyntaxKind.VariableDeclarator);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "c");
+                                    }
+                                    N(SyntaxKind.CommaToken);
+                                    M(SyntaxKind.VariableDeclarator);
+                                    {
+                                        M(SyntaxKind.IdentifierToken);
+                                    }
+                                }
+                                M(SyntaxKind.SemicolonToken);
+                            }
                             M(SyntaxKind.CloseBraceToken);
                         }
                     }
@@ -537,6 +529,7 @@ void Goo() {
                 }
                 N(SyntaxKind.EndOfFileToken);
             }
+            EOF();
         }
 
         [Fact, WorkItem(14167, "https://github.com/dotnet/roslyn/issues/14167")]
@@ -584,5 +577,91 @@ public void HangingLambdaParsing_Bug14167()
             EOF();
         }
 
+        [Fact]
+        public void Arglist_01()
+        {
+            string source = "(__arglist) => { }";
+            UsingExpression(source,
+                // (1,1): error CS1073: Unexpected token '=>'
+                // (__arglist) => { }
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "(__arglist)").WithArguments("=>").WithLocation(1, 1));
+
+            N(SyntaxKind.ParenthesizedExpression);
+            {
+                N(SyntaxKind.OpenParenToken);
+                N(SyntaxKind.ArgListExpression);
+                {
+                    N(SyntaxKind.ArgListKeyword);
+                }
+                N(SyntaxKind.CloseParenToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Arglist_02()
+        {
+            string source = "(int x, __arglist) => { }";
+            UsingExpression(source,
+                // (1,1): error CS1073: Unexpected token '=>'
+                // (int x, __arglist) => { }
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "(int x, __arglist)").WithArguments("=>").WithLocation(1, 1));
+
+            N(SyntaxKind.TupleExpression);
+            {
+                N(SyntaxKind.OpenParenToken);
+                N(SyntaxKind.Argument);
+                {
+                    N(SyntaxKind.DeclarationExpression);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.SingleVariableDesignation);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                }
+                N(SyntaxKind.CommaToken);
+                N(SyntaxKind.Argument);
+                {
+                    N(SyntaxKind.ArgListExpression);
+                    {
+                        N(SyntaxKind.ArgListKeyword);
+                    }
+                }
+                N(SyntaxKind.CloseParenToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Arglist_03()
+        {
+            string source = "static (__arglist) => { }";
+            UsingExpression(source,
+                // (1,9): error CS1041: Identifier expected; '__arglist' is a keyword
+                // static (__arglist) => { }
+                Diagnostic(ErrorCode.ERR_IdentifierExpectedKW, "__arglist").WithArguments("", "__arglist").WithLocation(1, 9));
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.StaticKeyword);
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaReturnTypeParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaReturnTypeParsingTests.cs
new file mode 100644
index 0000000000000..1d692aa61be24
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaReturnTypeParsingTests.cs
@@ -0,0 +1,4080 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public class LambdaReturnTypeParsingTests : ParsingTests
+    {
+        public LambdaReturnTypeParsingTests(ITestOutputHelper output) : base(output) { }
+
+        protected override SyntaxTree ParseTree(string text, CSharpParseOptions? options)
+        {
+            return SyntaxFactory.ParseSyntaxTree(text, options: options);
+        }
+
+        protected override CSharpSyntaxNode ParseNode(string text, CSharpParseOptions? options)
+        {
+            return SyntaxFactory.ParseExpression(text, options: options);
+        }
+
+        public static IEnumerable<object[]> AsyncAndStaticModifiers()
+        {
+            yield return getModifiers("");
+            yield return getModifiers("async", SyntaxKind.AsyncKeyword);
+            yield return getModifiers("static", SyntaxKind.StaticKeyword);
+            yield return getModifiers("async static", SyntaxKind.AsyncKeyword, SyntaxKind.StaticKeyword);
+            yield return getModifiers("static async", SyntaxKind.StaticKeyword, SyntaxKind.AsyncKeyword);
+
+            static object[] getModifiers(string modifiers, params SyntaxKind[] modifierKinds) => new object[] { modifiers, modifierKinds };
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void IdentifierReturnType_01(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " T () => default";
+            UsingExpression(source, TestOptions.Regular9);
+            verify();
+
+            UsingExpression(source, TestOptions.RegularPreview);
+            verify();
+
+            void verify()
+            {
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    foreach (var modifier in modifierKinds)
+                    {
+                        N(modifier);
+                    }
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.DefaultLiteralExpression);
+                    {
+                        N(SyntaxKind.DefaultKeyword);
+                    }
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void IdentifierReturnType_02()
+        {
+            string source = "T (x) => { return x; }";
+            UsingExpression(source, TestOptions.Regular9);
+            verify();
+
+            UsingExpression(source, TestOptions.RegularPreview);
+            verify();
+
+            void verify()
+            {
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.Block);
+                    {
+                        N(SyntaxKind.OpenBraceToken);
+                        N(SyntaxKind.ReturnStatement);
+                        {
+                            N(SyntaxKind.ReturnKeyword);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.CloseBraceToken);
+                    }
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void IdentifierReturnType_03()
+        {
+            string source = "T (T x) => x";
+            UsingExpression(source, TestOptions.Regular9);
+            verify();
+
+            UsingExpression(source, TestOptions.RegularPreview);
+            verify();
+
+            void verify()
+            {
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "T");
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void IdentifierReturnType_04()
+        {
+            string source = "var (x, y) => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "var");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "y");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void IdentifierReturnType_05()
+        {
+            string source = "T x => y";
+            UsingExpression(source, TestOptions.Regular9,
+                // (1,1): error CS1073: Unexpected token 'x'
+                // T x => y
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "T").WithArguments("x").WithLocation(1, 1));
+            verify();
+
+            UsingExpression(source, TestOptions.RegularPreview,
+                // (1,1): error CS1073: Unexpected token 'x'
+                // T x => y
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "T").WithArguments("x").WithLocation(1, 1));
+            verify();
+
+            void verify()
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "T");
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void NamedLambda_01()
+        {
+            string source = "T F() => default";
+            UsingExpression(source,
+                // (1,1): error CS1073: Unexpected token 'F'
+                // T F() => default
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "T").WithArguments("F").WithLocation(1, 1));
+
+            N(SyntaxKind.IdentifierName);
+            {
+                N(SyntaxKind.IdentifierToken, "T");
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NamedLambda_02()
+        {
+            string source = "async T F() => { }";
+            UsingExpression(source,
+                // (1,1): error CS1073: Unexpected token 'T'
+                // async T F() => { }
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "async").WithArguments("T").WithLocation(1, 1));
+
+            N(SyntaxKind.IdentifierName);
+            {
+                N(SyntaxKind.IdentifierToken, "async");
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NamedLambda_03()
+        {
+            string source = "static T F(int x) => { }";
+            UsingExpression(source,
+                // (1,1): error CS1525: Invalid expression term 'static'
+                // static T F(int x) => { }
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "static").WithArguments("static").WithLocation(1, 1),
+                // (1,1): error CS1073: Unexpected token 'static'
+                // static T F(int x) => { }
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "").WithArguments("static").WithLocation(1, 1));
+
+            M(SyntaxKind.IdentifierName);
+            {
+                M(SyntaxKind.IdentifierToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void AnonymousMethod_01()
+        {
+            string source = "delegate T { return default; }";
+            verify(source, TestOptions.Regular9);
+            verify(source, TestOptions.RegularPreview);
+
+            void verify(string source, CSharpParseOptions parseOptions)
+            {
+                UsingExpression(source, parseOptions,
+                    // (1,1): error CS1073: Unexpected token 'T'
+                    // delegate T { return default; }
+                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "delegate ").WithArguments("T").WithLocation(1, 1),
+                    // (1,10): error CS1514: { expected
+                    // delegate T { return default; }
+                    Diagnostic(ErrorCode.ERR_LbraceExpected, "T").WithLocation(1, 10));
+
+                N(SyntaxKind.AnonymousMethodExpression);
+                {
+                    N(SyntaxKind.DelegateKeyword);
+                    M(SyntaxKind.Block);
+                    {
+                        M(SyntaxKind.OpenBraceToken);
+                        M(SyntaxKind.CloseBraceToken);
+                    }
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void AnonymousMethod_02()
+        {
+            string source = "delegate int (int x) { return x; }";
+            verify(source, TestOptions.Regular9);
+            verify(source, TestOptions.RegularPreview);
+
+            void verify(string source, CSharpParseOptions parseOptions)
+            {
+                UsingExpression(source, parseOptions,
+                    // (1,1): error CS1073: Unexpected token 'int'
+                    // delegate int (int x) { return x; }
+                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "delegate ").WithArguments("int").WithLocation(1, 1),
+                    // (1,10): error CS1514: { expected
+                    // delegate int (int x) { return x; }
+                    Diagnostic(ErrorCode.ERR_LbraceExpected, "int").WithLocation(1, 10));
+
+                N(SyntaxKind.AnonymousMethodExpression);
+                {
+                    N(SyntaxKind.DelegateKeyword);
+                    M(SyntaxKind.Block);
+                    {
+                        M(SyntaxKind.OpenBraceToken);
+                        M(SyntaxKind.CloseBraceToken);
+                    }
+                }
+                EOF();
+            }
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void PrimitiveReturnType_01(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " int (_) => 0";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.IntKeyword);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "_");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.NumericLiteralExpression);
+                {
+                    N(SyntaxKind.NumericLiteralToken, "0");
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void PrimitiveReturnType_02(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " void () => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void ArrayReturnType(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " T[] () => null";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.ArrayType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.ArrayRankSpecifier);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.OmittedArraySizeExpression);
+                        {
+                            N(SyntaxKind.OmittedArraySizeExpressionToken);
+                        }
+                        N(SyntaxKind.CloseBracketToken);
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.NullLiteralExpression);
+                {
+                    N(SyntaxKind.NullKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void PointerReturnType_01(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " T* () => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.PointerType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.AsteriskToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void PointerReturnType_02()
+        {
+            string source = "int* () => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.PointerType);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.AsteriskToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void PointerReturnType_03()
+        {
+            string source = "void* () => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.PointerType);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.VoidKeyword);
+                    }
+                    N(SyntaxKind.AsteriskToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void FunctionPointerReturnType_01(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " delegate*<void> () => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.FunctionPointerType);
+                {
+                    N(SyntaxKind.DelegateKeyword);
+                    N(SyntaxKind.AsteriskToken);
+                    N(SyntaxKind.FunctionPointerParameterList);
+                    {
+                        N(SyntaxKind.LessThanToken);
+                        N(SyntaxKind.FunctionPointerParameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.VoidKeyword);
+                            }
+                        }
+                        N(SyntaxKind.GreaterThanToken);
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void FunctionPointerReturnType_02()
+        {
+            string source = "delegate* unmanaged[Cdecl]<ref delegate*<void>, void> () => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.FunctionPointerType);
+                {
+                    N(SyntaxKind.DelegateKeyword);
+                    N(SyntaxKind.AsteriskToken);
+                    N(SyntaxKind.FunctionPointerCallingConvention);
+                    {
+                        N(SyntaxKind.UnmanagedKeyword);
+                        N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList);
+                        {
+                            N(SyntaxKind.OpenBracketToken);
+                            N(SyntaxKind.FunctionPointerUnmanagedCallingConvention);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Cdecl");
+                            }
+                            N(SyntaxKind.CloseBracketToken);
+                        }
+                    }
+                    N(SyntaxKind.FunctionPointerParameterList);
+                    {
+                        N(SyntaxKind.LessThanToken);
+                        N(SyntaxKind.FunctionPointerParameter);
+                        {
+                            N(SyntaxKind.RefKeyword);
+                            N(SyntaxKind.FunctionPointerType);
+                            {
+                                N(SyntaxKind.DelegateKeyword);
+                                N(SyntaxKind.AsteriskToken);
+                                N(SyntaxKind.FunctionPointerParameterList);
+                                {
+                                    N(SyntaxKind.LessThanToken);
+                                    N(SyntaxKind.FunctionPointerParameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.VoidKeyword);
+                                        }
+                                    }
+                                    N(SyntaxKind.GreaterThanToken);
+                                }
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.FunctionPointerParameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.VoidKeyword);
+                            }
+                        }
+                        N(SyntaxKind.GreaterThanToken);
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_01()
+        {
+            string source = "int? () => null";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.NullLiteralExpression);
+                {
+                    N(SyntaxKind.NullKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_02()
+        {
+            string source = "int? () => x : y";
+            UsingExpression(source,
+                // (1,1): error CS1073: Unexpected token ':'
+                // int? () => x : y
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "int? () => x").WithArguments(":").WithLocation(1, 1));
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_03()
+        {
+            string source = "int[]? () => null";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.ArrayType);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ArrayRankSpecifier);
+                        {
+                            N(SyntaxKind.OpenBracketToken);
+                            N(SyntaxKind.OmittedArraySizeExpression);
+                            {
+                                N(SyntaxKind.OmittedArraySizeExpressionToken);
+                            }
+                            N(SyntaxKind.CloseBracketToken);
+                        }
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.NullLiteralExpression);
+                {
+                    N(SyntaxKind.NullKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_04()
+        {
+            string source = "int[]? () => x : y";
+            UsingExpression(source,
+                // (1,1): error CS1073: Unexpected token ':'
+                // int[]? () => x : y
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "int[]? () => x").WithArguments(":").WithLocation(1, 1));
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.ArrayType);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ArrayRankSpecifier);
+                        {
+                            N(SyntaxKind.OpenBracketToken);
+                            N(SyntaxKind.OmittedArraySizeExpression);
+                            {
+                                N(SyntaxKind.OmittedArraySizeExpressionToken);
+                            }
+                            N(SyntaxKind.CloseBracketToken);
+                        }
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_05()
+        {
+            string source = "int.MaxValue? () => null";
+            UsingExpression(source,
+                // (1,25): error CS1003: Syntax error, ':' expected
+                // int.MaxValue? () => null
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(":", "").WithLocation(1, 25),
+                // (1,25): error CS1733: Expected expression
+                // int.MaxValue? () => null
+                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 25));
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.SimpleMemberAccessExpression);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.DotToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "MaxValue");
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.NullLiteralExpression);
+                    {
+                        N(SyntaxKind.NullKeyword);
+                    }
+                }
+                M(SyntaxKind.ColonToken);
+                M(SyntaxKind.IdentifierName);
+                {
+                    M(SyntaxKind.IdentifierToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_06()
+        {
+            string source = "int.MaxValue? () => x : y";
+            UsingExpression(source);
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.SimpleMemberAccessExpression);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.DotToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "MaxValue");
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "y");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_07()
+        {
+            string source = "T? () => x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_08()
+        {
+            string source = "T? () => x : y";
+            UsingExpression(source);
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "T");
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "y");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_09()
+        {
+            string source = "(x, y)? () => x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.TupleType);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.TupleElement);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.TupleElement);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "y");
+                            }
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_10()
+        {
+            string source = "(x, y)? () => x : z";
+            UsingExpression(source);
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.TupleExpression);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "y");
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "z");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_11()
+        {
+            string source = "T[]? () => x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.ArrayType);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "T");
+                        }
+                        N(SyntaxKind.ArrayRankSpecifier);
+                        {
+                            N(SyntaxKind.OpenBracketToken);
+                            N(SyntaxKind.OmittedArraySizeExpression);
+                            {
+                                N(SyntaxKind.OmittedArraySizeExpressionToken);
+                            }
+                            N(SyntaxKind.CloseBracketToken);
+                        }
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_12()
+        {
+            string source = "T[]? () => x : y";
+            UsingExpression(source,
+                // (1,3): error CS0443: Syntax error; value expected
+                // T[]? () => x : y
+                Diagnostic(ErrorCode.ERR_ValueExpected, "]").WithLocation(1, 3));
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.ElementAccessExpression);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.BracketedArgumentList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        M(SyntaxKind.Argument);
+                        {
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.CloseBracketToken);
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "y");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_13()
+        {
+            string source = "T[0]? () => x";
+            UsingExpression(source,
+                // (1,14): error CS1003: Syntax error, ':' expected
+                // T[0]? () => x
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(":", "").WithLocation(1, 14),
+                // (1,14): error CS1733: Expected expression
+                // T[0]? () => x
+                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 14));
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.ElementAccessExpression);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.BracketedArgumentList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Argument);
+                        {
+                            N(SyntaxKind.NumericLiteralExpression);
+                            {
+                                N(SyntaxKind.NumericLiteralToken, "0");
+                            }
+                        }
+                        N(SyntaxKind.CloseBracketToken);
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                M(SyntaxKind.ColonToken);
+                M(SyntaxKind.IdentifierName);
+                {
+                    M(SyntaxKind.IdentifierToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_14()
+        {
+            string source = "T[0]? () => x : y";
+            UsingExpression(source);
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.ElementAccessExpression);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.BracketedArgumentList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Argument);
+                        {
+                            N(SyntaxKind.NumericLiteralExpression);
+                            {
+                                N(SyntaxKind.NumericLiteralToken, "0");
+                            }
+                        }
+                        N(SyntaxKind.CloseBracketToken);
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "y");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_15()
+        {
+            string source = "A<B>? () => x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "A");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "B");
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_16()
+        {
+            string source = "A<B>? () => x : y";
+            UsingExpression(source);
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.GenericName);
+                {
+                    N(SyntaxKind.IdentifierToken, "A");
+                    N(SyntaxKind.TypeArgumentList);
+                    {
+                        N(SyntaxKind.LessThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "B");
+                        }
+                        N(SyntaxKind.GreaterThanToken);
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "y");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_17()
+        {
+            string source = "int*? () => x";
+            UsingExpression(source,
+                // (1,1): error CS1525: Invalid expression term 'int'
+                // int*? () => x
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "int").WithArguments("int").WithLocation(1, 1),
+                // (1,5): error CS1525: Invalid expression term '?'
+                // int*? () => x
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "?").WithArguments("?").WithLocation(1, 5),
+                // (1,14): error CS1003: Syntax error, ':' expected
+                // int*? () => x
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(":", "").WithLocation(1, 14),
+                // (1,14): error CS1733: Expected expression
+                // int*? () => x
+                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 14));
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.MultiplyExpression);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.AsteriskToken);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                M(SyntaxKind.ColonToken);
+                M(SyntaxKind.IdentifierName);
+                {
+                    M(SyntaxKind.IdentifierToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_18()
+        {
+            string source = "int*? () => x : y";
+            UsingExpression(source,
+                // (1,1): error CS1525: Invalid expression term 'int'
+                // int*? () => x : y
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "int").WithArguments("int").WithLocation(1, 1),
+                // (1,5): error CS1525: Invalid expression term '?'
+                // int*? () => x : y
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "?").WithArguments("?").WithLocation(1, 5));
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.MultiplyExpression);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.AsteriskToken);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "y");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_19()
+        {
+            string source = "delegate*<void>? () => x";
+            UsingExpression(source,
+                // (1,9): error CS1514: { expected
+                // delegate*<void>? () => x
+                Diagnostic(ErrorCode.ERR_LbraceExpected, "*").WithLocation(1, 9),
+                // (1,9): warning CS8848: Operator '*' cannot be used here due to precedence. Use parentheses to disambiguate.
+                // delegate*<void>? () => x
+                Diagnostic(ErrorCode.WRN_PrecedenceInversion, "*").WithArguments("*").WithLocation(1, 9),
+                // (1,10): error CS1525: Invalid expression term '<'
+                // delegate*<void>? () => x
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "<").WithArguments("<").WithLocation(1, 10),
+                // (1,11): error CS1525: Invalid expression term 'void'
+                // delegate*<void>? () => x
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "void").WithArguments("void").WithLocation(1, 11),
+                // (1,16): error CS1525: Invalid expression term '?'
+                // delegate*<void>? () => x
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "?").WithArguments("?").WithLocation(1, 16),
+                // (1,25): error CS1003: Syntax error, ':' expected
+                // delegate*<void>? () => x
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(":", "").WithLocation(1, 25),
+                // (1,25): error CS1733: Expected expression
+                // delegate*<void>? () => x
+                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 25));
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.GreaterThanExpression);
+                {
+                    N(SyntaxKind.LessThanExpression);
+                    {
+                        N(SyntaxKind.MultiplyExpression);
+                        {
+                            N(SyntaxKind.AnonymousMethodExpression);
+                            {
+                                N(SyntaxKind.DelegateKeyword);
+                                M(SyntaxKind.Block);
+                                {
+                                    M(SyntaxKind.OpenBraceToken);
+                                    M(SyntaxKind.CloseBraceToken);
+                                }
+                            }
+                            N(SyntaxKind.AsteriskToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.LessThanToken);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.VoidKeyword);
+                        }
+                    }
+                    N(SyntaxKind.GreaterThanToken);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                M(SyntaxKind.ColonToken);
+                M(SyntaxKind.IdentifierName);
+                {
+                    M(SyntaxKind.IdentifierToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_20()
+        {
+            string source = "delegate*<void>? () => x : y";
+            UsingExpression(source,
+                // (1,9): error CS1514: { expected
+                // delegate*<void>? () => x : y
+                Diagnostic(ErrorCode.ERR_LbraceExpected, "*").WithLocation(1, 9),
+                // (1,9): warning CS8848: Operator '*' cannot be used here due to precedence. Use parentheses to disambiguate.
+                // delegate*<void>? () => x : y
+                Diagnostic(ErrorCode.WRN_PrecedenceInversion, "*").WithArguments("*").WithLocation(1, 9),
+                // (1,10): error CS1525: Invalid expression term '<'
+                // delegate*<void>? () => x : y
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "<").WithArguments("<").WithLocation(1, 10),
+                // (1,11): error CS1525: Invalid expression term 'void'
+                // delegate*<void>? () => x : y
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "void").WithArguments("void").WithLocation(1, 11),
+                // (1,16): error CS1525: Invalid expression term '?'
+                // delegate*<void>? () => x : y
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "?").WithArguments("?").WithLocation(1, 16));
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.GreaterThanExpression);
+                {
+                    N(SyntaxKind.LessThanExpression);
+                    {
+                        N(SyntaxKind.MultiplyExpression);
+                        {
+                            N(SyntaxKind.AnonymousMethodExpression);
+                            {
+                                N(SyntaxKind.DelegateKeyword);
+                                M(SyntaxKind.Block);
+                                {
+                                    M(SyntaxKind.OpenBraceToken);
+                                    M(SyntaxKind.CloseBraceToken);
+                                }
+                            }
+                            N(SyntaxKind.AsteriskToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.LessThanToken);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.VoidKeyword);
+                        }
+                    }
+                    N(SyntaxKind.GreaterThanToken);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "y");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_21()
+        {
+            string source = "static T? () => x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.StaticKeyword);
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_22()
+        {
+            string source = "static T? () => x : y";
+            UsingExpression(source,
+                // (1,1): error CS1073: Unexpected token ':'
+                // static T? () => x : y
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "static T? () => x").WithArguments(":").WithLocation(1, 1));
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.StaticKeyword);
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_23()
+        {
+            string source = "async? () => x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "async");
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_24()
+        {
+            string source = "async? () => x : y";
+            UsingExpression(source);
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "async");
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "y");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_25()
+        {
+            string source = "async T? () => x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.AsyncKeyword);
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_26()
+        {
+            string source = "async T? () => x : y";
+            UsingExpression(source,
+                // (1,1): error CS1073: Unexpected token 'T'
+                // async T? () => x : y
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "async").WithArguments("T").WithLocation(1, 1));
+
+            N(SyntaxKind.IdentifierName);
+            {
+                N(SyntaxKind.IdentifierToken, "async");
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_27()
+        {
+            string source = "[A] T? () => x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_28()
+        {
+            string source = "[A] T? () => x : y";
+            UsingExpression(source,
+                // (1,1): error CS1073: Unexpected token ':'
+                // [A] T? () => x : y
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "[A] T? () => x").WithArguments(":").WithLocation(1, 1));
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                N(SyntaxKind.NullableType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.QuestionToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_29()
+        {
+            string source = "b? c? () => x : y";
+            UsingExpression(source,
+                // (1,18): error CS1003: Syntax error, ':' expected
+                // b? c? () => x : y
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(":", "").WithLocation(1, 18),
+                // (1,18): error CS1733: Expected expression
+                // b? c? () => x : y
+                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 18));
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "b");
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ConditionalExpression);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "c");
+                    }
+                    N(SyntaxKind.QuestionToken);
+                    N(SyntaxKind.ParenthesizedLambdaExpression);
+                    {
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.ColonToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "y");
+                    }
+                }
+                M(SyntaxKind.ColonToken);
+                M(SyntaxKind.IdentifierName);
+                {
+                    M(SyntaxKind.IdentifierToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_30()
+        {
+            string source = "b? c? () => x : y : z";
+            UsingExpression(source);
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "b");
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ConditionalExpression);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "c");
+                    }
+                    N(SyntaxKind.QuestionToken);
+                    N(SyntaxKind.ParenthesizedLambdaExpression);
+                    {
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.ColonToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "y");
+                    }
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "z");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void NullableReturnTypeOrConditional_31()
+        {
+            string source = "b? (c? () => x) : y";
+            UsingExpression(source);
+
+            N(SyntaxKind.ConditionalExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "b");
+                }
+                N(SyntaxKind.QuestionToken);
+                N(SyntaxKind.ParenthesizedExpression);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.ParenthesizedLambdaExpression);
+                    {
+                        N(SyntaxKind.NullableType);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "c");
+                            }
+                            N(SyntaxKind.QuestionToken);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.ColonToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "y");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void QualifiedNameReturnType_01()
+        {
+            string source = "A.B () => null";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.QualifiedName);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "A");
+                    }
+                    N(SyntaxKind.DotToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "B");
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.NullLiteralExpression);
+                {
+                    N(SyntaxKind.NullKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void QualifiedNameReturnType_02(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " A::B () => null";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.AliasQualifiedName);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "A");
+                    }
+                    N(SyntaxKind.ColonColonToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "B");
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.NullLiteralExpression);
+                {
+                    N(SyntaxKind.NullKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void QualifiedNameReturnType_03()
+        {
+            string source = "global::T () => null";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.AliasQualifiedName);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.GlobalKeyword);
+                    }
+                    N(SyntaxKind.ColonColonToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.NullLiteralExpression);
+                {
+                    N(SyntaxKind.NullKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void GenericReturnType_01()
+        {
+            string source = "A<B> () => null";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.GenericName);
+                {
+                    N(SyntaxKind.IdentifierToken, "A");
+                    N(SyntaxKind.TypeArgumentList);
+                    {
+                        N(SyntaxKind.LessThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "B");
+                        }
+                        N(SyntaxKind.GreaterThanToken);
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.NullLiteralExpression);
+                {
+                    N(SyntaxKind.NullKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void GenericReturnType_02(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " A<B>.C () => null";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.QualifiedName);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "A");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "B");
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.DotToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "C");
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.NullLiteralExpression);
+                {
+                    N(SyntaxKind.NullKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void TupleReturnType_01(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " (x, y) (x, y) => (x, y)";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.TupleType);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.TupleElement);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.TupleElement);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "y");
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "y");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.TupleExpression);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "y");
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TupleReturnType_02()
+        {
+            string source = "(int x, object y) () => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.TupleType);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.TupleElement);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.TupleElement);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.ObjectKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "y");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Nested_01()
+        {
+            string source = "A () => () => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "A");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.Block);
+                    {
+                        N(SyntaxKind.OpenBraceToken);
+                        N(SyntaxKind.CloseBraceToken);
+                    }
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Nested_02()
+        {
+            string source = "A () => B () => null";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "A");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "B");
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.NullLiteralExpression);
+                    {
+                        N(SyntaxKind.NullKeyword);
+                    }
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Nested_03()
+        {
+            string source = "object () => void () => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.ObjectKeyword);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.ParenthesizedLambdaExpression);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.VoidKeyword);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.Block);
+                    {
+                        N(SyntaxKind.OpenBraceToken);
+                        N(SyntaxKind.CloseBraceToken);
+                    }
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void Ref_01(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " ref int (ref int x) => ref x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.RefType);
+                {
+                    N(SyntaxKind.RefKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.RefKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.RefExpression);
+                {
+                    N(SyntaxKind.RefKeyword);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void Ref_02(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = modifiers + " ref readonly A () => ref x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.RefType);
+                {
+                    N(SyntaxKind.RefKeyword);
+                    N(SyntaxKind.ReadOnlyKeyword);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "A");
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.RefExpression);
+                {
+                    N(SyntaxKind.RefKeyword);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Ref_03()
+        {
+            string source = "ref D () => ref int () => ref x";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.RefType);
+                {
+                    N(SyntaxKind.RefKeyword);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "D");
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.RefExpression);
+                {
+                    N(SyntaxKind.RefKeyword);
+                    N(SyntaxKind.ParenthesizedLambdaExpression);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.RefExpression);
+                        {
+                            N(SyntaxKind.RefKeyword);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                    }
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_01()
+        {
+            string source = "F(a, b)";
+            UsingExpression(source);
+
+            N(SyntaxKind.InvocationExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ArgumentList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "a");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "b");
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_02()
+        {
+            string source = "F(a,";
+            UsingExpression(source,
+                // (1,5): error CS1733: Expected expression
+                // F(a,
+                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 5),
+                // (1,5): error CS1026: ) expected
+                // F(a,
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(1, 5));
+
+            N(SyntaxKind.InvocationExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ArgumentList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "a");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    M(SyntaxKind.Argument);
+                    {
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    M(SyntaxKind.CloseParenToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_03()
+        {
+            string source = "F(ref a, out b, in c)";
+            UsingExpression(source);
+
+            N(SyntaxKind.InvocationExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ArgumentList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.RefKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "a");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.OutKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "b");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.InKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "c");
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_04()
+        {
+            string source = "F(ref a,";
+            UsingExpression(source,
+                // (1,9): error CS1733: Expected expression
+                // F(ref a,
+                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 9),
+                // (1,9): error CS1026: ) expected
+                // F(ref a,
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(1, 9));
+
+            N(SyntaxKind.InvocationExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ArgumentList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.RefKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "a");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    M(SyntaxKind.Argument);
+                    {
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    M(SyntaxKind.CloseParenToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_05()
+        {
+            string source = "F(A a, B b)";
+            UsingExpression(source,
+                // (1,5): error CS1003: Syntax error, ',' expected
+                // F(A a, B b)
+                Diagnostic(ErrorCode.ERR_SyntaxError, "a").WithArguments(",", "").WithLocation(1, 5),
+                // (1,10): error CS1003: Syntax error, ',' expected
+                // F(A a, B b)
+                Diagnostic(ErrorCode.ERR_SyntaxError, "b").WithArguments(",", "").WithLocation(1, 10));
+
+            N(SyntaxKind.InvocationExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ArgumentList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                    }
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "a");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "B");
+                        }
+                    }
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "b");
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_06()
+        {
+            string source = "F(ref A a, out B b, in C c)";
+            UsingExpression(source,
+                // (1,9): error CS1003: Syntax error, ',' expected
+                // F(ref A a, out B b, in C c)
+                Diagnostic(ErrorCode.ERR_SyntaxError, "a").WithArguments(",", "").WithLocation(1, 9),
+                // (1,26): error CS1003: Syntax error, ',' expected
+                // F(ref A a, out B b, in C c)
+                Diagnostic(ErrorCode.ERR_SyntaxError, "c").WithArguments(",", "").WithLocation(1, 26));
+
+            N(SyntaxKind.InvocationExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ArgumentList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.RefKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                    }
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "a");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.OutKeyword);
+                        N(SyntaxKind.DeclarationExpression);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "B");
+                            }
+                            N(SyntaxKind.SingleVariableDesignation);
+                            {
+                                N(SyntaxKind.IdentifierToken, "b");
+                            }
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.InKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "C");
+                        }
+                    }
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "c");
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_07()
+        {
+            string source = "F(ref A a,";
+            UsingExpression(source,
+                // (1,9): error CS1003: Syntax error, ',' expected
+                // F(ref A a,
+                Diagnostic(ErrorCode.ERR_SyntaxError, "a").WithArguments(",", "").WithLocation(1, 9),
+                // (1,11): error CS1733: Expected expression
+                // F(ref A a,
+                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 11),
+                // (1,11): error CS1026: ) expected
+                // F(ref A a,
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(1, 11));
+
+            N(SyntaxKind.InvocationExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ArgumentList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.RefKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                    }
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Argument);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "a");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    M(SyntaxKind.Argument);
+                    {
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    M(SyntaxKind.CloseParenToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_08()
+        {
+            string source = "F(a, b) =>";
+            UsingExpression(source,
+                // (1,11): error CS1733: Expected expression
+                // F(a, b) =>
+                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 11));
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "a");
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "b");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                M(SyntaxKind.IdentifierName);
+                {
+                    M(SyntaxKind.IdentifierToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_09()
+        {
+            string source = "F(a, b) => {";
+            UsingExpression(source,
+                // (1,13): error CS1513: } expected
+                // F(a, b) => {
+                Diagnostic(ErrorCode.ERR_RbraceExpected, "").WithLocation(1, 13));
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "a");
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "b");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    M(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_10()
+        {
+            string source = "F(a, b) => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "a");
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierToken, "b");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_11()
+        {
+            string source = "F(ref a, out b, in c) => { }";
+            UsingExpression(source,
+                // (1,8): error CS1001: Identifier expected
+                // F(ref a, out b, in c) => { }
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, ",").WithLocation(1, 8),
+                // (1,15): error CS1001: Identifier expected
+                // F(ref a, out b, in c) => { }
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, ",").WithLocation(1, 15),
+                // (1,21): error CS1001: Identifier expected
+                // F(ref a, out b, in c) => { }
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 21));
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.RefKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "a");
+                        }
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.OutKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "b");
+                        }
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.InKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "c");
+                        }
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_12()
+        {
+            string source = "F(A a, B b) => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                        N(SyntaxKind.IdentifierToken, "a");
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "B");
+                        }
+                        N(SyntaxKind.IdentifierToken, "b");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void InvocationOrLambda_13()
+        {
+            string source = "F(ref A a, out B b, in C c) => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "F");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.RefKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                        N(SyntaxKind.IdentifierToken, "a");
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.OutKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "B");
+                        }
+                        N(SyntaxKind.IdentifierToken, "b");
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.InKeyword);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "C");
+                        }
+                        N(SyntaxKind.IdentifierToken, "c");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void SwitchExpression_01()
+        {
+            string source = "x switch { int () => 0 => 1 }";
+            UsingExpression(source,
+                // (1,24): error CS1003: Syntax error, ',' expected
+                // x switch { int () => 0 => 1 }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 24),
+                // (1,24): error CS8504: Pattern missing
+                // x switch { int () => 0 => 1 }
+                Diagnostic(ErrorCode.ERR_MissingPattern, "=>").WithLocation(1, 24));
+
+            N(SyntaxKind.SwitchExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+                N(SyntaxKind.SwitchKeyword);
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.SwitchExpressionArm);
+                {
+                    N(SyntaxKind.RecursivePattern);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.PositionalPatternClause);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.NumericLiteralExpression);
+                    {
+                        N(SyntaxKind.NumericLiteralToken, "0");
+                    }
+                }
+                M(SyntaxKind.CommaToken);
+                N(SyntaxKind.SwitchExpressionArm);
+                {
+                    M(SyntaxKind.ConstantPattern);
+                    {
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.NumericLiteralExpression);
+                    {
+                        N(SyntaxKind.NumericLiteralToken, "1");
+                    }
+                }
+                N(SyntaxKind.CloseBraceToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void SwitchExpression_02()
+        {
+            string source = "x switch { T () => { } => 1 }";
+            UsingExpression(source,
+                // (1,20): error CS1525: Invalid expression term '{'
+                // x switch { T () => { } => 1 }
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "{").WithArguments("{").WithLocation(1, 20),
+                // (1,20): error CS1003: Syntax error, ',' expected
+                // x switch { T () => { } => 1 }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "{").WithArguments(",", "{").WithLocation(1, 20));
+
+            N(SyntaxKind.SwitchExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+                N(SyntaxKind.SwitchKeyword);
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.SwitchExpressionArm);
+                {
+                    N(SyntaxKind.RecursivePattern);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "T");
+                        }
+                        N(SyntaxKind.PositionalPatternClause);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                }
+                M(SyntaxKind.CommaToken);
+                N(SyntaxKind.SwitchExpressionArm);
+                {
+                    N(SyntaxKind.RecursivePattern);
+                    {
+                        N(SyntaxKind.PropertyPatternClause);
+                        {
+                            N(SyntaxKind.OpenBraceToken);
+                            N(SyntaxKind.CloseBraceToken);
+                        }
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.NumericLiteralExpression);
+                    {
+                        N(SyntaxKind.NumericLiteralToken, "1");
+                    }
+                }
+                N(SyntaxKind.CloseBraceToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void SwitchExpression_03()
+        {
+            string source = "x switch { static T? () => { } => 1 }";
+            UsingExpression(source,
+                // (1,12): error CS1525: Invalid expression term 'static'
+                // x switch { static T? () => { } => 1 }
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "static").WithArguments("static").WithLocation(1, 12),
+                // (1,12): error CS1003: Syntax error, '=>' expected
+                // x switch { static T? () => { } => 1 }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "static").WithArguments("=>", "static").WithLocation(1, 12),
+                // (1,32): error CS1003: Syntax error, ',' expected
+                // x switch { static T? () => { } => 1 }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 32),
+                // (1,32): error CS8504: Pattern missing
+                // x switch { static T? () => { } => 1 }
+                Diagnostic(ErrorCode.ERR_MissingPattern, "=>").WithLocation(1, 32));
+
+            N(SyntaxKind.SwitchExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "x");
+                }
+                N(SyntaxKind.SwitchKeyword);
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.SwitchExpressionArm);
+                {
+                    M(SyntaxKind.ConstantPattern);
+                    {
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    M(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.ParenthesizedLambdaExpression);
+                    {
+                        N(SyntaxKind.StaticKeyword);
+                        N(SyntaxKind.NullableType);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "T");
+                            }
+                            N(SyntaxKind.QuestionToken);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.Block);
+                        {
+                            N(SyntaxKind.OpenBraceToken);
+                            N(SyntaxKind.CloseBraceToken);
+                        }
+                    }
+                }
+                M(SyntaxKind.CommaToken);
+                N(SyntaxKind.SwitchExpressionArm);
+                {
+                    M(SyntaxKind.ConstantPattern);
+                    {
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.NumericLiteralExpression);
+                    {
+                        N(SyntaxKind.NumericLiteralToken, "1");
+                    }
+                }
+                N(SyntaxKind.CloseBraceToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Async_01()
+        {
+            string source = "async[] () => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.ArrayType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "async");
+                    }
+                    N(SyntaxKind.ArrayRankSpecifier);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.OmittedArraySizeExpression);
+                        {
+                            N(SyntaxKind.OmittedArraySizeExpressionToken);
+                        }
+                        N(SyntaxKind.CloseBracketToken);
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Async_02()
+        {
+            string source = "async* () => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.PointerType);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "async");
+                    }
+                    N(SyntaxKind.AsteriskToken);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Async_03()
+        {
+            string source = "async.B () => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.QualifiedName);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "async");
+                    }
+                    N(SyntaxKind.DotToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "B");
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Async_04()
+        {
+            string source = "async<T> () => { }";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.GenericName);
+                {
+                    N(SyntaxKind.IdentifierToken, "async");
+                    N(SyntaxKind.TypeArgumentList);
+                    {
+                        N(SyntaxKind.LessThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "T");
+                        }
+                        N(SyntaxKind.GreaterThanToken);
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Async_05()
+        {
+            string source = "@async () => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "@async");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Async_06()
+        {
+            string source = "async async (async async) => async";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.AsyncKeyword);
+                N(SyntaxKind.AsyncKeyword);
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "async");
+                        }
+                        N(SyntaxKind.IdentifierToken, "async");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "async");
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Dynamic_01()
+        {
+            string source = "dynamic () => default";
+            UsingExpression(source, TestOptions.Regular9);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "dynamic");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Dynamic_02()
+        {
+            string source = "Delegate d = dynamic () => default;";
+            UsingDeclaration(source, TestOptions.Regular9);
+
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Delegate");
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "d");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "dynamic");
+                                }
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.DefaultLiteralExpression);
+                                {
+                                    N(SyntaxKind.DefaultKeyword);
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void Attributes_01(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = $"[A] {modifiers} void () => {{ }}";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Attributes_02()
+        {
+            string source = "[A][B] T () => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "B");
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                N(SyntaxKind.IdentifierName);
+                {
+                    N(SyntaxKind.IdentifierToken, "T");
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void Attributes_03(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = $"[A, B] {modifiers} ref T () => default";
+            UsingExpression(source);
+
+            N(SyntaxKind.ParenthesizedLambdaExpression);
+            {
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                    }
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "B");
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                foreach (var modifier in modifierKinds)
+                {
+                    N(modifier);
+                }
+                N(SyntaxKind.RefType);
+                {
+                    N(SyntaxKind.RefKeyword);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                }
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.EqualsGreaterThanToken);
+                N(SyntaxKind.DefaultLiteralExpression);
+                {
+                    N(SyntaxKind.DefaultKeyword);
+                }
+            }
+            EOF();
+        }
+
+        [MemberData(nameof(AsyncAndStaticModifiers))]
+        [Theory]
+        public void AttributeArgument_01(string modifiers, SyntaxKind[] modifierKinds)
+        {
+            string source = $"[A({modifiers} void () => {{ }})] class C {{ }}";
+            UsingDeclaration(source);
+
+            N(SyntaxKind.ClassDeclaration);
+            {
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                        N(SyntaxKind.AttributeArgumentList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.AttributeArgument);
+                            {
+                                N(SyntaxKind.ParenthesizedLambdaExpression);
+                                {
+                                    foreach (var modifier in modifierKinds)
+                                    {
+                                        N(modifier);
+                                    }
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.VoidKeyword);
+                                    }
+                                    N(SyntaxKind.ParameterList);
+                                    {
+                                        N(SyntaxKind.OpenParenToken);
+                                        N(SyntaxKind.CloseParenToken);
+                                    }
+                                    N(SyntaxKind.EqualsGreaterThanToken);
+                                    N(SyntaxKind.Block);
+                                    {
+                                        N(SyntaxKind.OpenBraceToken);
+                                        N(SyntaxKind.CloseBraceToken);
+                                    }
+                                }
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                N(SyntaxKind.ClassKeyword);
+                N(SyntaxKind.IdentifierToken, "C");
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.CloseBraceToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void AttributeArgument_02()
+        {
+            string source = "[A(T () => default)] class C { }";
+            UsingDeclaration(source);
+
+            N(SyntaxKind.ClassDeclaration);
+            {
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                        N(SyntaxKind.AttributeArgumentList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.AttributeArgument);
+                            {
+                                N(SyntaxKind.ParenthesizedLambdaExpression);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "T");
+                                    }
+                                    N(SyntaxKind.ParameterList);
+                                    {
+                                        N(SyntaxKind.OpenParenToken);
+                                        N(SyntaxKind.CloseParenToken);
+                                    }
+                                    N(SyntaxKind.EqualsGreaterThanToken);
+                                    N(SyntaxKind.DefaultLiteralExpression);
+                                    {
+                                        N(SyntaxKind.DefaultKeyword);
+                                    }
+                                }
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                N(SyntaxKind.ClassKeyword);
+                N(SyntaxKind.IdentifierToken, "C");
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.CloseBraceToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void AttributeArgument_03()
+        {
+            string source = "[A(delegate*<void> () => default)] class C { }";
+            UsingDeclaration(source);
+
+            N(SyntaxKind.ClassDeclaration);
+            {
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                        N(SyntaxKind.AttributeArgumentList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.AttributeArgument);
+                            {
+                                N(SyntaxKind.ParenthesizedLambdaExpression);
+                                {
+                                    N(SyntaxKind.FunctionPointerType);
+                                    {
+                                        N(SyntaxKind.DelegateKeyword);
+                                        N(SyntaxKind.AsteriskToken);
+                                        N(SyntaxKind.FunctionPointerParameterList);
+                                        {
+                                            N(SyntaxKind.LessThanToken);
+                                            N(SyntaxKind.FunctionPointerParameter);
+                                            {
+                                                N(SyntaxKind.PredefinedType);
+                                                {
+                                                    N(SyntaxKind.VoidKeyword);
+                                                }
+                                            }
+                                            N(SyntaxKind.GreaterThanToken);
+                                        }
+                                    }
+                                    N(SyntaxKind.ParameterList);
+                                    {
+                                        N(SyntaxKind.OpenParenToken);
+                                        N(SyntaxKind.CloseParenToken);
+                                    }
+                                    N(SyntaxKind.EqualsGreaterThanToken);
+                                    N(SyntaxKind.DefaultLiteralExpression);
+                                    {
+                                        N(SyntaxKind.DefaultKeyword);
+                                    }
+                                }
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                N(SyntaxKind.ClassKeyword);
+                N(SyntaxKind.IdentifierToken, "C");
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.CloseBraceToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void AttributeArgument_04()
+        {
+            string source = "[A(ref int () => default)] class C { }";
+            UsingDeclaration(source);
+
+            N(SyntaxKind.ClassDeclaration);
+            {
+                N(SyntaxKind.AttributeList);
+                {
+                    N(SyntaxKind.OpenBracketToken);
+                    N(SyntaxKind.Attribute);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "A");
+                        }
+                        N(SyntaxKind.AttributeArgumentList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.AttributeArgument);
+                            {
+                                N(SyntaxKind.ParenthesizedLambdaExpression);
+                                {
+                                    N(SyntaxKind.RefType);
+                                    {
+                                        N(SyntaxKind.RefKeyword);
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.IntKeyword);
+                                        }
+                                    }
+                                    N(SyntaxKind.ParameterList);
+                                    {
+                                        N(SyntaxKind.OpenParenToken);
+                                        N(SyntaxKind.CloseParenToken);
+                                    }
+                                    N(SyntaxKind.EqualsGreaterThanToken);
+                                    N(SyntaxKind.DefaultLiteralExpression);
+                                    {
+                                        N(SyntaxKind.DefaultKeyword);
+                                    }
+                                }
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                    }
+                    N(SyntaxKind.CloseBracketToken);
+                }
+                N(SyntaxKind.ClassKeyword);
+                N(SyntaxKind.IdentifierToken, "C");
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.CloseBraceToken);
+            }
+            EOF();
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LineSpanDirectiveParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LineSpanDirectiveParsingTests.cs
new file mode 100644
index 0000000000000..3c7df69f9561e
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LineSpanDirectiveParsingTests.cs
@@ -0,0 +1,1833 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public class LineSpanDirectiveParsingTests : ParsingTests
+    {
+        public LineSpanDirectiveParsingTests(ITestOutputHelper output) : base(output) { }
+
+        protected override SyntaxTree ParseTree(string text, CSharpParseOptions? options)
+        {
+            return SyntaxFactory.ParseSyntaxTree(text, options: options);
+        }
+
+        protected override CSharpSyntaxNode ParseNode(string text, CSharpParseOptions? options)
+        {
+            return SyntaxFactory.ParseExpression(text, options: options);
+        }
+
+        private void UsingLineDirective(string text, CSharpParseOptions? options, params DiagnosticDescription[] expectedErrors)
+        {
+            var node = ParseTree(text, options).GetCompilationUnitRoot();
+            Validate(text, node, expectedErrors);
+            UsingNode(node.GetDirectives().Single(d => d.Kind() is SyntaxKind.LineDirectiveTrivia or SyntaxKind.LineSpanDirectiveTrivia));
+        }
+
+        [Fact]
+        public void IsActive()
+        {
+            string source =
+@"#if IsActive
+#line (1, 2) - (3, 4) ""file.cs""
+#endif";
+
+            UsingLineDirective(source, TestOptions.Regular9);
+            verify();
+
+            UsingLineDirective(source, TestOptions.Regular9.WithPreprocessorSymbols("IsActive"),
+                // (2,2): error CS8773: Feature 'line span directive' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // #line (1, 2) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "line").WithArguments("line span directive", "10.0").WithLocation(2, 2));
+            verify();
+
+            void verify()
+            {
+                N(SyntaxKind.LineSpanDirectiveTrivia);
+                {
+                    N(SyntaxKind.HashToken);
+                    N(SyntaxKind.LineKeyword);
+                    N(SyntaxKind.LineDirectivePosition);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.NumericLiteralToken, "1");
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.NumericLiteralToken, "2");
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.MinusToken);
+                    N(SyntaxKind.LineDirectivePosition);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.NumericLiteralToken, "3");
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.NumericLiteralToken, "4");
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                    N(SyntaxKind.EndOfDirectiveToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void LineDirective_01()
+        {
+            string source = @"#line (1, 2) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, TestOptions.Regular9,
+                // (1,2): error CS8773: Feature 'line span directive' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // #line (1, 2) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "line").WithArguments("line span directive", "10.0").WithLocation(1, 2));
+            verify();
+
+            UsingLineDirective(source, TestOptions.Regular10);
+            verify();
+
+            void verify()
+            {
+                N(SyntaxKind.LineSpanDirectiveTrivia);
+                {
+                    N(SyntaxKind.HashToken);
+                    N(SyntaxKind.LineKeyword);
+                    N(SyntaxKind.LineDirectivePosition);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.NumericLiteralToken, "1");
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.NumericLiteralToken, "2");
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.MinusToken);
+                    N(SyntaxKind.LineDirectivePosition);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.NumericLiteralToken, "3");
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.NumericLiteralToken, "4");
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                    N(SyntaxKind.EndOfDirectiveToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void LineDirective_02()
+        {
+            string source = @"#line (1, 2) - (3, 4) 5 ""file.cs""";
+
+            UsingLineDirective(source, TestOptions.Regular9,
+                // (1,2): error CS8773: Feature 'line span directive' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // #line (1, 2) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "line").WithArguments("line span directive", "10.0").WithLocation(1, 2));
+            verify();
+
+            UsingLineDirective(source, TestOptions.Regular10);
+            verify();
+
+            void verify()
+            {
+                N(SyntaxKind.LineSpanDirectiveTrivia);
+                {
+                    N(SyntaxKind.HashToken);
+                    N(SyntaxKind.LineKeyword);
+                    N(SyntaxKind.LineDirectivePosition);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.NumericLiteralToken, "1");
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.NumericLiteralToken, "2");
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.MinusToken);
+                    N(SyntaxKind.LineDirectivePosition);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.NumericLiteralToken, "3");
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.NumericLiteralToken, "4");
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.NumericLiteralToken, "5");
+                    N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                    N(SyntaxKind.EndOfDirectiveToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void LineDirective_03()
+        {
+            string source = @"#line (1, 2) - (3, 4) """"";
+
+            UsingLineDirective(source, options: null);
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void LineDirective_04()
+        {
+            string source = @"   #   line   (   1   ,   2   )   -   (   3   ,   4   )   5   ""   """;
+
+            UsingLineDirective(source, options: null);
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.NumericLiteralToken, "5");
+                N(SyntaxKind.StringLiteralToken, "\"   \"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void LineDirective_05()
+        {
+            string source = @"#line(1,2)-(3,4)""file.cs""";
+
+            UsingLineDirective(source, options: null);
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void LineDirective_06()
+        {
+            string source = @"#line(1,2)-(3,4)5""file.cs""";
+
+            UsingLineDirective(source, options: null);
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.NumericLiteralToken, "5");
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_01()
+        {
+            string source = @"#line (";
+
+            UsingLineDirective(source, options: null,
+                // (1,8): error CS8938: The #line directive value is missing or out of range
+                // #line (
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "").WithLocation(1, 8));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_02()
+        {
+            string source = @"#line (1";
+
+            UsingLineDirective(source, options: null,
+                // (1,9): error CS1003: Syntax error, ',' expected
+                // #line (1
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",", "").WithLocation(1, 9));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_03()
+        {
+            string source = @"#line (1,";
+
+            UsingLineDirective(source, options: null,
+                // (1,10): error CS8938: The #line directive value is missing or out of range
+                // #line (1,
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "").WithLocation(1, 10));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_04()
+        {
+            string source = @"#line (1, 2";
+
+            UsingLineDirective(source, options: null,
+                // (1,12): error CS1026: ) expected
+                // #line (1, 2
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(1, 12));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_05()
+        {
+            string source = @"#line (1, 2)";
+
+            UsingLineDirective(source, options: null,
+                // (1,13): error CS1003: Syntax error, '-' expected
+                // #line (1, 2)
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("-", "").WithLocation(1, 13));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_06()
+        {
+            string source = @"#line (1, 2) -";
+
+            UsingLineDirective(source, options: null,
+                // (1,15): error CS1003: Syntax error, '(' expected
+                // #line (1, 2) -
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("(", "").WithLocation(1, 15));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_07()
+        {
+            string source = @"#line (1, 2) - (";
+
+            UsingLineDirective(source, options: null,
+                // (1,17): error CS8938: The #line directive value is missing or out of range
+                // #line (1, 2) - (
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "").WithLocation(1, 17));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_08()
+        {
+            string source = @"#line (1, 2) - (3";
+
+            UsingLineDirective(source, options: null,
+                // (1,18): error CS1003: Syntax error, ',' expected
+                // #line (1, 2) - (3
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",", "").WithLocation(1, 18));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_09()
+        {
+            string source = @"#line (1, 2) - (3,";
+
+            UsingLineDirective(source, options: null,
+                // (1,19): error CS8938: The #line directive value is missing or out of range
+                // #line (1, 2) - (3,
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "").WithLocation(1, 19));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_10()
+        {
+            string source = @"#line (1, 2) - (3, 4";
+
+            UsingLineDirective(source, options: null,
+                // (1,21): error CS1026: ) expected
+                // #line (1, 2) - (3, 4
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(1, 21));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_11()
+        {
+            string source = @"#line (1, 2) - (3, 4)";
+
+            UsingLineDirective(source, options: null,
+                // (1,22): error CS1578: Quoted file name, single-line comment or end-of-line expected
+                // #line (1, 2) - (3, 4)
+                Diagnostic(ErrorCode.ERR_MissingPPFile, "").WithLocation(1, 22));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_12()
+        {
+            string source = @"#line (1, 2) - (3, 4) 5";
+
+            UsingLineDirective(source, options: null,
+                // (1,24): error CS1578: Quoted file name, single-line comment or end-of-line expected
+                // #line (1, 2) - (3, 4) 5
+                Diagnostic(ErrorCode.ERR_MissingPPFile, "").WithLocation(1, 24));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.NumericLiteralToken, "5");
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Incomplete_13()
+        {
+            ParseIncompleteSyntax(@"#line (1, 2) - (3, 4) 5 ""file.cs""");
+        }
+
+        [Fact]
+        public void Missing_01()
+        {
+            string source = @"#line 1, 2) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,8): error CS1578: Quoted file name, single-line comment or end-of-line expected
+                // #line 1, 2) - 3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_MissingPPFile, ",").WithLocation(1, 8));
+
+            N(SyntaxKind.LineDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.NumericLiteralToken, "1");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_02()
+        {
+            string source = @"#line (, 2) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,8): error CS8938: The #line directive value is missing or out of range
+                // #line (, 2) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, ",").WithLocation(1, 8));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_03()
+        {
+            string source = @"#line (1 2) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,10): error CS1003: Syntax error, ',' expected
+                // #line (1 2) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_SyntaxError, "2").WithArguments(",", "").WithLocation(1, 10));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_04()
+        {
+            string source = @"#line (1, ) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,11): error CS8938: The #line directive value is missing or out of range
+                // #line (1, ) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, ")").WithLocation(1, 11));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_05()
+        {
+            string source = @"#line (1, 2 - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,13): error CS1026: ) expected
+                // #line (1, 2 - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "-").WithLocation(1, 13));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    M(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_06()
+        {
+            string source = @"#line (1, 2) (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,14): error CS1003: Syntax error, '-' expected
+                // #line (1, 2) (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments("-", "(").WithLocation(1, 14));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_07()
+        {
+            string source = @"#line (1, 2) - 3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,16): error CS1003: Syntax error, '(' expected
+                // #line (1, 2) - 3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_SyntaxError, "3").WithArguments("(", "").WithLocation(1, 16));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_08()
+        {
+            string source = @"#line (1, 2) - (, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,17): error CS8938: The #line directive value is missing or out of range
+                // #line (1, 2) - (, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, ",").WithLocation(1, 17));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_09()
+        {
+            string source = @"#line (1, 2) - (3 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,19): error CS1003: Syntax error, ',' expected
+                // #line (1, 2) - (3 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_SyntaxError, "4").WithArguments(",", "").WithLocation(1, 19));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_10()
+        {
+            string source = @"#line (1, 2) - (3, ) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,20): error CS8938: The #line directive value is missing or out of range
+                // #line (1, 2) - (3, ) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, ")").WithLocation(1, 20));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void Missing_11()
+        {
+            string source = @"#line (1, 2) - (3, 4 ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,22): error CS1026: ) expected
+                // #line (1, 2) - (3, 4 "file.cs"
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, @"""file.cs""").WithLocation(1, 22));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    M(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_01()
+        {
+            string source = @"#line ('1', 2) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,8): error CS8938: The #line directive value is missing or out of range
+                // #line ('1', 2) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "'").WithLocation(1, 8));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_02()
+        {
+            string source = @"#line (1, ""2"") - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,11): error CS8938: The #line directive value is missing or out of range
+                // #line (1, "2") - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, @"""2""").WithLocation(1, 11));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"2\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_03()
+        {
+            string source = @"#line (1, 2) - (0b11, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,17): error CS8938: The #line directive value is missing or out of range
+                // #line (1, 2) - (0b11, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "0").WithLocation(1, 17));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "0");
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_04()
+        {
+            string source = @"#line (1, 2) - (3, 0x04) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,20): error CS8938: The #line directive value is missing or out of range
+                // #line (1, 2) - (3, 0x04) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "0").WithLocation(1, 20));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "0");
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_05()
+        {
+            string source = @"#line (null, 2) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,8): error CS8938: The #line directive value is missing or out of range
+                // #line (null, 2) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "null").WithLocation(1, 8));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_06()
+        {
+            string source = @"#line (1, true) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,11): error CS8938: The #line directive value is missing or out of range
+                // #line (1, true) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "true").WithLocation(1, 11));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_07()
+        {
+            string source = @"#line (1, 2) - (int, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,17): error CS8938: The #line directive value is missing or out of range
+                // #line (1, 2) - (int, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "int").WithLocation(1, 17));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_08()
+        {
+            string source = @"#line (1u, 2) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,9): error CS1003: Syntax error, ',' expected
+                // #line (1u, 2) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_SyntaxError, "u").WithArguments(",", "").WithLocation(1, 9));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_09()
+        {
+            string source = @"#line (1, 2f) - (3, 4) ""  """;
+
+            UsingLineDirective(source, options: null,
+                // (1,12): error CS1026: ) expected
+                // #line (1, 2f) - (3, 4) "  "
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "f").WithLocation(1, 12));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.MinusToken);
+                M(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void UnexpectedToken_10()
+        {
+            string source = @"#line (1, 2) - (3, 4) file.cs";
+
+            UsingLineDirective(source, options: null,
+                // (1,23): error CS1578: Quoted file name, single-line comment or end-of-line expected
+                // #line (1, 2) - (3, 4) file.cs
+                Diagnostic(ErrorCode.ERR_MissingPPFile, "file").WithLocation(1, 23));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "3");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "4");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void VerifyValue_01()
+        {
+            string source = @"#line (-1, 2) - (3, 4) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,8): error CS8938: The #line directive value is missing or out of range
+                // #line (-1, 2) - (3, 4) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "-").WithLocation(1, 8));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CommaToken);
+                    M(SyntaxKind.NumericLiteralToken);
+                    M(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    M(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "2");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                M(SyntaxKind.StringLiteralToken);
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void VerifyValue_02()
+        {
+            string source = @"#line (0, 0) - (0, 0) 0 ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,8): error CS8938: The #line directive value is missing or out of range
+                // #line (0, 0) - (0, 0) 0 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "0").WithLocation(1, 8),
+                // (1,11): error CS8938: The #line directive value is missing or out of range
+                // #line (0, 0) - (0, 0) 0 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "0").WithLocation(1, 11),
+                // (1,17): error CS8938: The #line directive value is missing or out of range
+                // #line (0, 0) - (0, 0) 0 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "0").WithLocation(1, 17),
+                // (1,20): error CS8938: The #line directive value is missing or out of range
+                // #line (0, 0) - (0, 0) 0 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "0").WithLocation(1, 20),
+                // (1,23): error CS8938: The #line directive value is missing or out of range
+                // #line (0, 0) - (0, 0) 0 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "0").WithLocation(1, 23));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "0");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "0");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "0");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "0");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.NumericLiteralToken, "0");
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void VerifyValue_03()
+        {
+            string source = @"#line (16707565, 65536) - (16707565, 65536) 65536 ""file.cs""";
+
+            UsingLineDirective(source, options: null);
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "16707565");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "65536");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "16707565");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "65536");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.NumericLiteralToken, "65536");
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void VerifyValue_04()
+        {
+            string source = @"#line (16707566, 65537) - (16707566, 65537) 65537 ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,8): error CS8938: The #line directive value is missing or out of range
+                // #line (16707566, 65537) - (16707566, 65537) 65537 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "16707566").WithLocation(1, 8),
+                // (1,18): error CS8938: The #line directive value is missing or out of range
+                // #line (16707566, 65537) - (16707566, 65537) 65537 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "65537").WithLocation(1, 18),
+                // (1,28): error CS8938: The #line directive value is missing or out of range
+                // #line (16707566, 65537) - (16707566, 65537) 65537 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "16707566").WithLocation(1, 28),
+                // (1,38): error CS8938: The #line directive value is missing or out of range
+                // #line (16707566, 65537) - (16707566, 65537) 65537 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "65537").WithLocation(1, 38),
+                // (1,45): error CS8938: The #line directive value is missing or out of range
+                // #line (16707566, 65537) - (16707566, 65537) 65537 "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, "65537").WithLocation(1, 45));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "16707566");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "65537");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "16707566");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "65537");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.NumericLiteralToken, "65537");
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void VerifySpan_01()
+        {
+            string source = @"#line (10, 20) - (10, 20) ""file.cs""";
+
+            UsingLineDirective(source, options: null);
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "10");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "20");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "10");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "20");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void VerifySpan_02()
+        {
+            string source = @"#line (10, 20) - (10, 19) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,18): error CS8939: The #line directive end position must be greater than or equal to the start position
+                // #line (10, 20) - (10, 19) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveEndLessThanStart, "(10, 19)").WithLocation(1, 18));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "10");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "20");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "10");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "19");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void VerifySpan_03()
+        {
+            string source = @"#line (10, 20) - (9, 20) ""file.cs""";
+
+            UsingLineDirective(source, options: null,
+                // (1,18): error CS8939: The #line directive end position must be greater than or equal to the start position
+                // #line (10, 20) - (9, 20) "file.cs"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveEndLessThanStart, "(9, 20)").WithLocation(1, 18));
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "10");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "20");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "9");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "20");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void VerifySpan_04()
+        {
+            string source = @"#line (10, 20) - (11, 1) ""file.cs""";
+
+            UsingLineDirective(source, options: null);
+
+            N(SyntaxKind.LineSpanDirectiveTrivia);
+            {
+                N(SyntaxKind.HashToken);
+                N(SyntaxKind.LineKeyword);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "10");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "20");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.MinusToken);
+                N(SyntaxKind.LineDirectivePosition);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.NumericLiteralToken, "11");
+                    N(SyntaxKind.CommaToken);
+                    N(SyntaxKind.NumericLiteralToken, "1");
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.StringLiteralToken, "\"file.cs\"");
+                N(SyntaxKind.EndOfDirectiveToken);
+            }
+            EOF();
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LocalFunctionParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LocalFunctionParsingTests.cs
index f0034659cc1c1..6932b167ff190 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/LocalFunctionParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LocalFunctionParsingTests.cs
@@ -1273,10 +1273,10 @@ class c
             N(SyntaxKind.CompilationUnit);
             {
                 N(SyntaxKind.ClassDeclaration);
-                N(SyntaxKind.ClassKeyword);
-                N(SyntaxKind.IdentifierToken, "c");
-                N(SyntaxKind.OpenBraceToken);
                 {
+                    N(SyntaxKind.ClassKeyword);
+                    N(SyntaxKind.IdentifierToken, "c");
+                    N(SyntaxKind.OpenBraceToken);
                     N(SyntaxKind.MethodDeclaration);
                     {
                         N(SyntaxKind.PredefinedType);
@@ -1290,8 +1290,8 @@ class c
                             N(SyntaxKind.CloseParenToken);
                         }
                         N(SyntaxKind.Block);
-                        N(SyntaxKind.OpenBraceToken);
                         {
+                            N(SyntaxKind.OpenBraceToken);
                             N(SyntaxKind.LocalFunctionStatement);
                             {
                                 N(SyntaxKind.IdentifierName);
@@ -1313,18 +1313,18 @@ class c
                                         N(SyntaxKind.IdentifierName);
                                         {
                                             N(SyntaxKind.IdentifierToken, "await");
-                                            N(SyntaxKind.ArgumentList);
-                                            {
-                                                N(SyntaxKind.OpenParenToken);
-                                                N(SyntaxKind.CloseParenToken);
-                                            }
+                                        }
+                                        N(SyntaxKind.ArgumentList);
+                                        {
+                                            N(SyntaxKind.OpenParenToken);
+                                            N(SyntaxKind.CloseParenToken);
                                         }
                                     }
                                 }
                                 N(SyntaxKind.SemicolonToken);
                             }
+                            N(SyntaxKind.CloseBraceToken);
                         }
-                        N(SyntaxKind.CloseBraceToken);
                     }
                     N(SyntaxKind.MethodDeclaration);
                     {
@@ -1339,41 +1339,40 @@ class c
                             N(SyntaxKind.CloseParenToken);
                         }
                         N(SyntaxKind.Block);
-                        N(SyntaxKind.OpenBraceToken);
                         {
+                            N(SyntaxKind.OpenBraceToken);
                             N(SyntaxKind.ExpressionStatement);
                             {
-                                N(SyntaxKind.InvocationExpression);
-                                N(SyntaxKind.IdentifierName, "await");
-                                {
-                                    N(SyntaxKind.IdentifierToken, "await");
-                                }
-                                N(SyntaxKind.ArgumentList);
-                                {
-                                    N(SyntaxKind.OpenParenToken);
-                                    N(SyntaxKind.CloseParenToken);
-                                }
-                                M(SyntaxKind.SemicolonToken);
-                                N(SyntaxKind.ExpressionStatement);
+                                N(SyntaxKind.ParenthesizedLambdaExpression);
                                 {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "await");
+                                    }
+                                    N(SyntaxKind.ParameterList);
+                                    {
+                                        N(SyntaxKind.OpenParenToken);
+                                        N(SyntaxKind.CloseParenToken);
+                                    }
+                                    N(SyntaxKind.EqualsGreaterThanToken);
                                     N(SyntaxKind.ObjectCreationExpression);
                                     {
                                         N(SyntaxKind.NewKeyword);
                                         N(SyntaxKind.IdentifierName);
                                         {
                                             N(SyntaxKind.IdentifierToken, "await");
-                                            N(SyntaxKind.ArgumentList);
-                                            {
-                                                N(SyntaxKind.OpenParenToken);
-                                                N(SyntaxKind.CloseParenToken);
-                                            }
+                                        }
+                                        N(SyntaxKind.ArgumentList);
+                                        {
+                                            N(SyntaxKind.OpenParenToken);
+                                            N(SyntaxKind.CloseParenToken);
                                         }
                                     }
                                 }
                                 N(SyntaxKind.SemicolonToken);
                             }
+                            N(SyntaxKind.CloseBraceToken);
                         }
-                        N(SyntaxKind.CloseBraceToken);
                     }
                     N(SyntaxKind.MethodDeclaration);
                     {
@@ -1389,8 +1388,8 @@ class c
                             N(SyntaxKind.CloseParenToken);
                         }
                         N(SyntaxKind.Block);
-                        N(SyntaxKind.OpenBraceToken);
                         {
+                            N(SyntaxKind.OpenBraceToken);
                             N(SyntaxKind.ExpressionStatement);
                             {
                                 N(SyntaxKind.AwaitExpression);
@@ -1416,11 +1415,11 @@ class c
                                     N(SyntaxKind.IdentifierName);
                                     {
                                         N(SyntaxKind.IdentifierToken, "await");
-                                        N(SyntaxKind.ArgumentList);
-                                        {
-                                            N(SyntaxKind.OpenParenToken);
-                                            N(SyntaxKind.CloseParenToken);
-                                        }
+                                    }
+                                    N(SyntaxKind.ArgumentList);
+                                    {
+                                        N(SyntaxKind.OpenParenToken);
+                                        N(SyntaxKind.CloseParenToken);
                                     }
                                 }
                                 N(SyntaxKind.SemicolonToken);
@@ -1441,8 +1440,8 @@ class c
                             N(SyntaxKind.CloseParenToken);
                         }
                         N(SyntaxKind.Block);
-                        N(SyntaxKind.OpenBraceToken);
                         {
+                            N(SyntaxKind.OpenBraceToken);
                             N(SyntaxKind.LocalFunctionStatement);
                             {
                                 N(SyntaxKind.IdentifierName);
@@ -1464,18 +1463,18 @@ class c
                                         N(SyntaxKind.IdentifierName);
                                         {
                                             N(SyntaxKind.IdentifierToken, "await");
-                                            N(SyntaxKind.ArgumentList);
-                                            {
-                                                N(SyntaxKind.OpenParenToken);
-                                                N(SyntaxKind.CloseParenToken);
-                                            }
+                                        }
+                                        N(SyntaxKind.ArgumentList);
+                                        {
+                                            N(SyntaxKind.OpenParenToken);
+                                            N(SyntaxKind.CloseParenToken);
                                         }
                                     }
                                 }
                                 N(SyntaxKind.SemicolonToken);
                             }
+                            N(SyntaxKind.CloseBraceToken);
                         }
-                        N(SyntaxKind.CloseBraceToken);
                     }
                     N(SyntaxKind.MethodDeclaration);
                     {
@@ -1491,8 +1490,8 @@ class c
                             N(SyntaxKind.CloseParenToken);
                         }
                         N(SyntaxKind.Block);
-                        N(SyntaxKind.OpenBraceToken);
                         {
+                            N(SyntaxKind.OpenBraceToken);
                             N(SyntaxKind.ExpressionStatement);
                             {
                                 N(SyntaxKind.AwaitExpression);
@@ -1521,11 +1520,11 @@ class c
                                     N(SyntaxKind.IdentifierName);
                                     {
                                         N(SyntaxKind.IdentifierToken, "await");
-                                        N(SyntaxKind.ArgumentList);
-                                        {
-                                            N(SyntaxKind.OpenParenToken);
-                                            N(SyntaxKind.CloseParenToken);
-                                        }
+                                    }
+                                    N(SyntaxKind.ArgumentList);
+                                    {
+                                        N(SyntaxKind.OpenParenToken);
+                                        N(SyntaxKind.CloseParenToken);
                                     }
                                 }
                                 N(SyntaxKind.SemicolonToken);
@@ -1533,10 +1532,10 @@ class c
                             N(SyntaxKind.CloseBraceToken);
                         }
                     }
+                    N(SyntaxKind.CloseBraceToken);
                 }
-                N(SyntaxKind.CloseBraceToken);
+                N(SyntaxKind.EndOfFileToken);
             }
-            N(SyntaxKind.EndOfFileToken);
             EOF();
         }
 
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/MemberDeclarationParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/MemberDeclarationParsingTests.cs
index 50721de54b62f..25d5105933468 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/MemberDeclarationParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/MemberDeclarationParsingTests.cs
@@ -24,6 +24,16 @@ private MemberDeclarationSyntax ParseDeclaration(string text, int offset = 0, Pa
             return SyntaxFactory.ParseMemberDeclaration(text, offset, options);
         }
 
+        private SyntaxTree UsingTree(string text, CSharpParseOptions options, params DiagnosticDescription[] expectedErrors)
+        {
+            var tree = base.UsingTree(text, options);
+
+            var actualErrors = tree.GetDiagnostics();
+            actualErrors.Verify(expectedErrors);
+
+            return tree;
+        }
+
         [Fact]
         [WorkItem(367, "https://github.com/dotnet/roslyn/issues/367")]
         public void ParsePrivate()
@@ -895,5 +905,5719 @@ public void SetAndInitAccessor()
                 EOF();
             }
         }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_01()
+        {
+            var error =
+                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // public int N.I.operator +(int x, int y) => x + y;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 12);
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("public int N.I.operator +(int x, int y) => x + y;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ? new[] { error } : new DiagnosticDescription[] { });
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "y");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.AddExpression);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.PlusToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "y");
+                                }
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_02()
+        {
+            var errors = new[] {
+                // (1,8): error CS1553: Declaration is not valid; use '+ operator <dest-type> (...' instead
+                // public int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_BadOperatorSyntax, "int").WithArguments("+").WithLocation(1, 8),
+                // (1,16): error CS1003: Syntax error, 'operator' expected
+                // public int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "implicit").WithArguments("operator", "implicit").WithLocation(1, 16),
+                // (1,16): error CS1019: Overloadable unary operator expected
+                // public int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_OvlUnaryOperatorExpected, "implicit").WithLocation(1, 16)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("public int N.I.implicit (int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // public int N.I.implicit (int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 12)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        M(SyntaxKind.OperatorKeyword);
+                        M(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_03()
+        {
+            var errors = new[] {
+                // (1,8): error CS1553: Declaration is not valid; use '+ operator <dest-type> (...' instead
+                // public int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_BadOperatorSyntax, "int").WithArguments("+").WithLocation(1, 8),
+                // (1,16): error CS1003: Syntax error, 'operator' expected
+                // public int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "explicit").WithArguments("operator", "explicit").WithLocation(1, 16),
+                // (1,16): error CS1019: Overloadable unary operator expected
+                // public int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_OvlUnaryOperatorExpected, "explicit").WithLocation(1, 16)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("public int N.I.explicit (int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // public int N.I.explicit (int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 12)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        M(SyntaxKind.OperatorKeyword);
+                        M(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_04()
+        {
+            var errors = new[] {
+                // (1,16): error CS1003: Syntax error, '.' expected
+                // public int N.I operator +(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 16)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("public int N.I operator +(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // public int N.I operator +(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I ").WithArguments("static abstract members in interfaces").WithLocation(1, 12)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_05()
+        {
+            var errors = new[] {
+                // (1,14): error CS1003: Syntax error, '.' expected
+                // public int I operator +(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 14)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("public int I operator +(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // public int I operator +(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I ").WithArguments("static abstract members in interfaces").WithLocation(1, 12)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_06()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("public int N::I::operator +(int x, int y) => x + y;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,16): error CS7000: Unexpected use of an aliased name
+                    // public int N::I::operator +(int x, int y) => x + y;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 16)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PublicKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.AliasQualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "N");
+                            }
+                            N(SyntaxKind.ColonColonToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                        }
+                        M(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "y");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.AddExpression);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.PlusToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "y");
+                            }
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_07()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("public int I::operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,13): error CS0687: The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead.
+                    // public int I::operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_AliasQualAsExpression, "::").WithLocation(1, 13)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PublicKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        M(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_08()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("public int I.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PublicKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_09()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("public int I<T>.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PublicKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.GenericName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                            N(SyntaxKind.TypeArgumentList);
+                            {
+                                N(SyntaxKind.LessThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "T");
+                                }
+                                N(SyntaxKind.GreaterThanToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_10()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("public int N1::N2::I.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,18): error CS7000: Unexpected use of an aliased name
+                    // public int N1::N2::I.operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 18)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PublicKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.AliasQualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N1");
+                                }
+                                N(SyntaxKind.ColonColonToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N2");
+                                }
+                            }
+                            M(SyntaxKind.DotToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_11()
+        {
+            var error =
+                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // public int N.I.operator +(int x, int y) => x + y;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 12);
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("public int N.I.operator +(int x, int y) => x + y;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ? new[] { error } : new DiagnosticDescription[] { });
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PublicKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                N(SyntaxKind.DotToken);
+                            }
+                            N(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "y");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.AddExpression);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                    }
+                                    N(SyntaxKind.PlusToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_12()
+        {
+            var errors = new[] {
+                // (1,8): error CS1553: Declaration is not valid; use '+ operator <dest-type> (...' instead
+                // public int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_BadOperatorSyntax, "int").WithArguments("+").WithLocation(1, 8),
+                // (1,16): error CS1003: Syntax error, 'operator' expected
+                // public int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "implicit").WithArguments("operator", "implicit").WithLocation(1, 16),
+                // (1,16): error CS1019: Overloadable unary operator expected
+                // public int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_OvlUnaryOperatorExpected, "implicit").WithLocation(1, 16)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("public int N.I.implicit (int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // public int N.I.implicit (int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 12)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PublicKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                N(SyntaxKind.DotToken);
+                            }
+                            M(SyntaxKind.OperatorKeyword);
+                            M(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_13()
+        {
+            var errors = new[] {
+                // (1,8): error CS1553: Declaration is not valid; use '+ operator <dest-type> (...' instead
+                // public int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_BadOperatorSyntax, "int").WithArguments("+").WithLocation(1, 8),
+                // (1,16): error CS1003: Syntax error, 'operator' expected
+                // public int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "explicit").WithArguments("operator", "explicit").WithLocation(1, 16),
+                // (1,16): error CS1019: Overloadable unary operator expected
+                // public int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_OvlUnaryOperatorExpected, "explicit").WithLocation(1, 16)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("public int N.I.explicit (int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // public int N.I.explicit (int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 12)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PublicKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                N(SyntaxKind.DotToken);
+                            }
+                            M(SyntaxKind.OperatorKeyword);
+                            M(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_14()
+        {
+            var errors = new[] {
+                // (1,16): error CS1003: Syntax error, '.' expected
+                // public int N.I operator +(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 16)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("public int N.I operator +(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // public int N.I operator +(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I ").WithArguments("static abstract members in interfaces").WithLocation(1, 12)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PublicKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                M(SyntaxKind.DotToken);
+                            }
+                            N(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_15()
+        {
+            var errors = new[] {
+                // (1,14): error CS1003: Syntax error, '.' expected
+                // public int I operator +(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 14)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("public int I operator +(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,12): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // public int I operator +(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I ").WithArguments("static abstract members in interfaces").WithLocation(1, 12)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PublicKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                                M(SyntaxKind.DotToken);
+                            }
+                            N(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_16()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("public int N::I::operator +(int x, int y) => x + y;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,16): error CS7000: Unexpected use of an aliased name
+                    // public int N::I::operator +(int x, int y) => x + y;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 16)
+                    );
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.AliasQualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.ColonColonToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "y");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.AddExpression);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.PlusToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "y");
+                                }
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_17()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("public int I::operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,13): error CS0687: The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead.
+                    // public int I::operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_AliasQualAsExpression, "::").WithLocation(1, 13)
+                    );
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_18()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("public int I.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_19()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("public int I<T>.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.GenericName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                                N(SyntaxKind.TypeArgumentList);
+                                {
+                                    N(SyntaxKind.LessThanToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "T");
+                                    }
+                                    N(SyntaxKind.GreaterThanToken);
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_20()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("public int N1::N2::I.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,18): error CS7000: Unexpected use of an aliased name
+                    // public int N1::N2::I.operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 18)
+                    );
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PublicKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.AliasQualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N1");
+                                    }
+                                    N(SyntaxKind.ColonColonToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N2");
+                                    }
+                                }
+                                M(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_21()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("public int I..operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,14): error CS1001: Identifier expected
+                    // public int I..operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ".operato").WithLocation(1, 14)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PublicKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_22()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("public int I . . operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,16): error CS1001: Identifier expected
+                    // public int I . . operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ".").WithLocation(1, 16)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PublicKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_23()
+        {
+            var error =
+                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // int N.I.operator +(int x, int y) => x + y;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 5);
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("int N.I.operator +(int x, int y) => x + y;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ? new[] { error } : new DiagnosticDescription[] { });
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "y");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.AddExpression);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.PlusToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "y");
+                                }
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_24()
+        {
+            var errors = new[] {
+                // (1,1): error CS1553: Declaration is not valid; use '+ operator <dest-type> (...' instead
+                // int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_BadOperatorSyntax, "int").WithArguments("+").WithLocation(1, 1),
+                // (1,9): error CS1003: Syntax error, 'operator' expected
+                // int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "implicit").WithArguments("operator", "implicit").WithLocation(1, 9),
+                // (1,9): error CS1019: Overloadable unary operator expected
+                // int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_OvlUnaryOperatorExpected, "implicit").WithLocation(1, 9)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("int N.I.implicit (int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // int N.I.implicit (int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 5)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        M(SyntaxKind.OperatorKeyword);
+                        M(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_25()
+        {
+            var errors = new[] {
+                // (1,1): error CS1553: Declaration is not valid; use '+ operator <dest-type> (...' instead
+                // int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_BadOperatorSyntax, "int").WithArguments("+").WithLocation(1, 1),
+                // (1,9): error CS1003: Syntax error, 'operator' expected
+                // int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "explicit").WithArguments("operator", "explicit").WithLocation(1, 9),
+                // (1,16): error CS1019: Overloadable unary operator expected
+                // int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_OvlUnaryOperatorExpected, "explicit").WithLocation(1, 9)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("int N.I.explicit (int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // int N.I.explicit (int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 5)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        M(SyntaxKind.OperatorKeyword);
+                        M(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_26()
+        {
+            var errors = new[] {
+                // (1,9): error CS1003: Syntax error, '.' expected
+                // int N.I operator +(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 9)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("int N.I operator +(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // int N.I operator +(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I ").WithArguments("static abstract members in interfaces").WithLocation(1, 5)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_27()
+        {
+            var errors = new[] {
+                // (1,7): error CS1003: Syntax error, '.' expected
+                // int I operator +(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 7)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("int I operator +(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // int I operator +(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I ").WithArguments("static abstract members in interfaces").WithLocation(1, 5)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_28()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("int N::I::operator +(int x, int y) => x + y;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,9): error CS7000: Unexpected use of an aliased name
+                    // int N::I::operator +(int x, int y) => x + y;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 9)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.AliasQualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "N");
+                            }
+                            N(SyntaxKind.ColonColonToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                        }
+                        M(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "y");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.AddExpression);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.PlusToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "y");
+                            }
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_29()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("int I::operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,6): error CS0687: The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead.
+                    // int I::operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_AliasQualAsExpression, "::").WithLocation(1, 6)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        M(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_30()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("int I.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_31()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("int I<T>.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.GenericName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                            N(SyntaxKind.TypeArgumentList);
+                            {
+                                N(SyntaxKind.LessThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "T");
+                                }
+                                N(SyntaxKind.GreaterThanToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_32()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("int N1::N2::I.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,11): error CS7000: Unexpected use of an aliased name
+                    // int N1::N2::I.operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 11)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.AliasQualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N1");
+                                }
+                                N(SyntaxKind.ColonColonToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N2");
+                                }
+                            }
+                            M(SyntaxKind.DotToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_33()
+        {
+            var error =
+                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // int N.I.operator +(int x, int y) => x + y;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 5);
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("int N.I.operator +(int x, int y) => x + y;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ? new[] { error } : new DiagnosticDescription[] { });
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                N(SyntaxKind.DotToken);
+                            }
+                            N(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "y");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.AddExpression);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                    }
+                                    N(SyntaxKind.PlusToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_34()
+        {
+            var errors = new[] {
+                // (1,1): error CS1553: Declaration is not valid; use '+ operator <dest-type> (...' instead
+                // int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_BadOperatorSyntax, "int").WithArguments("+").WithLocation(1, 1),
+                // (1,9): error CS1003: Syntax error, 'operator' expected
+                // int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "implicit").WithArguments("operator", "implicit").WithLocation(1, 9),
+                // (1,9): error CS1019: Overloadable unary operator expected
+                // int N.I.implicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_OvlUnaryOperatorExpected, "implicit").WithLocation(1, 9)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("int N.I.implicit (int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // int N.I.implicit (int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 5)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                N(SyntaxKind.DotToken);
+                            }
+                            M(SyntaxKind.OperatorKeyword);
+                            M(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_35()
+        {
+            var errors = new[] {
+                // (1,1): error CS1553: Declaration is not valid; use '+ operator <dest-type> (...' instead
+                // int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_BadOperatorSyntax, "int").WithArguments("+").WithLocation(1, 1),
+                // (1,9): error CS1003: Syntax error, 'operator' expected
+                // int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "explicit").WithArguments("operator", "explicit").WithLocation(1, 9),
+                // (1,9): error CS1019: Overloadable unary operator expected
+                // int N.I.explicit (int x) => x;
+                Diagnostic(ErrorCode.ERR_OvlUnaryOperatorExpected, "explicit").WithLocation(1, 9)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("int N.I.explicit (int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // int N.I.explicit (int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 5)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                N(SyntaxKind.DotToken);
+                            }
+                            M(SyntaxKind.OperatorKeyword);
+                            M(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_36()
+        {
+            var errors = new[] {
+                // (1,9): error CS1003: Syntax error, '.' expected
+                // int N.I operator +(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 9)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("int N.I operator +(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // int N.I operator +(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I ").WithArguments("static abstract members in interfaces").WithLocation(1, 5)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                M(SyntaxKind.DotToken);
+                            }
+                            N(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_37()
+        {
+            var errors = new[] {
+                // (1,7): error CS1003: Syntax error, '.' expected
+                // int I operator +(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 7)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("int I operator +(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,5): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // int I operator +(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I ").WithArguments("static abstract members in interfaces").WithLocation(1, 5)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.OperatorDeclaration);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                                M(SyntaxKind.DotToken);
+                            }
+                            N(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PlusToken);
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_38()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("int N::I::operator +(int x, int y) => x + y;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,9): error CS7000: Unexpected use of an aliased name
+                    // int N::I::operator +(int x, int y) => x + y;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 9)
+                    );
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.AliasQualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.ColonColonToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "y");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.AddExpression);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.PlusToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "y");
+                                }
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_39()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("int I::operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,6): error CS0687: The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead.
+                    // int I::operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_AliasQualAsExpression, "::").WithLocation(1, 6)
+                    );
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_40()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("int I.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_41()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("int I<T>.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.GenericName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                                N(SyntaxKind.TypeArgumentList);
+                                {
+                                    N(SyntaxKind.LessThanToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "T");
+                                    }
+                                    N(SyntaxKind.GreaterThanToken);
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_42()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("int N1::N2::I.operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,11): error CS7000: Unexpected use of an aliased name
+                    // int N1::N2::I.operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 11)
+                    );
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.AliasQualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N1");
+                                    }
+                                    N(SyntaxKind.ColonColonToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N2");
+                                    }
+                                }
+                                M(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_43()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("int I..operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,7): error CS1001: Identifier expected
+                    // int I..operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ".operato").WithLocation(1, 7)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_44()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("int I . . operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,9): error CS1001: Identifier expected
+                    // int I . . operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ".").WithLocation(1, 9)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_45()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("int N.I..operator +(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,9): error CS1001: Identifier expected
+                    // int N.I..operator +(int x) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ".operato").WithLocation(1, 9)
+                    );
+
+                N(SyntaxKind.OperatorDeclaration);
+                {
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PlusToken);
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_46()
+        {
+            var errors = new[] {
+                // (1,5): error CS1001: Identifier expected
+                // N.I.operator +(int x) => x;
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, "operator").WithLocation(1, 5)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("N.I.operator +(int x) => x;", options: options.WithLanguageVersion(version), errors);
+
+                    N(SyntaxKind.OperatorDeclaration);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PlusToken);
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void OperatorDeclaration_ExplicitImplementation_47()
+        {
+            var errors = new[] {
+                // (1,1): error CS1073: Unexpected token 'int'
+                // N.I. int(int x) => x;
+                Diagnostic(ErrorCode.ERR_UnexpectedToken, "N.I. ").WithArguments("int").WithLocation(1, 1),
+                // (1,6): error CS1001: Identifier expected
+                // N.I. int(int x) => x;
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, "int").WithLocation(1, 6)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("N.I. int(int x) => x;", options: options.WithLanguageVersion(version), errors);
+
+                    N(SyntaxKind.IncompleteMember);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_01()
+        {
+            var error =
+                // (1,10): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // implicit N.I.operator int(int x) => x;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 10);
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("implicit N.I.operator int(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ? new[] { error } : new DiagnosticDescription[] { });
+
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        N(SyntaxKind.ImplicitKeyword);
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_02()
+        {
+            var errors = new[] {
+                // (1,1): error CS1003: Syntax error, 'explicit' expected
+                // N.I.operator int(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "N").WithArguments("explicit", "").WithLocation(1, 1)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("N.I.operator int(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,1): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // N.I.operator int(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 1)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        M(SyntaxKind.ExplicitKeyword);
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_03()
+        {
+            var errors = new[] {
+                // (1,1): error CS1003: Syntax error, 'explicit' expected
+                // operator int(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments("explicit", "operator").WithLocation(1, 1)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("operator int(int x) => x;", options: options.WithLanguageVersion(version), errors);
+
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        M(SyntaxKind.ExplicitKeyword);
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_04()
+        {
+            var errors = new[] {
+                // (1,14): error CS1003: Syntax error, '.' expected
+                // implicit N.I operator int(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 14)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("implicit N.I operator int(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,10): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // implicit N.I operator int(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I ").WithArguments("static abstract members in interfaces").WithLocation(1, 10)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        N(SyntaxKind.ImplicitKeyword);
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_05()
+        {
+            var errors = new[] {
+                // (1,12): error CS1003: Syntax error, '.' expected
+                // explicit I operator int(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 12)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingDeclaration("explicit I operator int(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,10): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // explicit I operator int(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I ").WithArguments("static abstract members in interfaces").WithLocation(1, 10)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        N(SyntaxKind.ExplicitKeyword);
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_06()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("implicit N::I::operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,14): error CS7000: Unexpected use of an aliased name
+                    // implicit N::I::operator int(int x) => x;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 14)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ImplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.AliasQualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "N");
+                            }
+                            N(SyntaxKind.ColonColonToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                        }
+                        M(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_07()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I::operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,11): error CS0687: The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead.
+                    // explicit I::operator int(int x) => x;
+                    Diagnostic(ErrorCode.ERR_AliasQualAsExpression, "::").WithLocation(1, 11)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        M(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_08()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("implicit I.operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ImplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_09()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I<T>.operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.GenericName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                            N(SyntaxKind.TypeArgumentList);
+                            {
+                                N(SyntaxKind.LessThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "T");
+                                }
+                                N(SyntaxKind.GreaterThanToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_10()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("implicit N1::N2::I.operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,16): error CS7000: Unexpected use of an aliased name
+                    // implicit N1::N2::I.operator int(int x) => x;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 16)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ImplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.AliasQualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N1");
+                                }
+                                N(SyntaxKind.ColonColonToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N2");
+                                }
+                            }
+                            M(SyntaxKind.DotToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_11()
+        {
+            var error =
+                // (1,10): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // explicit N.I.operator int(int x) => x;
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 10);
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("explicit N.I.operator int(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ? new[] { error } : new DiagnosticDescription[] { });
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.ConversionOperatorDeclaration);
+                        {
+                            N(SyntaxKind.ExplicitKeyword);
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                N(SyntaxKind.DotToken);
+                            }
+                            N(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_12()
+        {
+            var errors = new[] {
+                // (1,14): error CS1003: Syntax error, '.' expected
+                // implicit N.I int(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "int").WithArguments(".", "int").WithLocation(1, 14),
+                // (1,14): error CS1003: Syntax error, 'operator' expected
+                // implicit N.I int(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "int").WithArguments("operator", "int").WithLocation(1, 14)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("implicit N.I int(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,10): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // implicit N.I int(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I ").WithArguments("static abstract members in interfaces").WithLocation(1, 10)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.ConversionOperatorDeclaration);
+                        {
+                            N(SyntaxKind.ImplicitKeyword);
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                M(SyntaxKind.DotToken);
+                            }
+                            M(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_13()
+        {
+            var errors = new[] {
+                // (1,15): error CS1003: Syntax error, 'operator' expected
+                // explicit N.I. int(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "int").WithArguments("operator", "int").WithLocation(1, 15)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("explicit N.I. int(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,10): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // explicit N.I. int(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I.").WithArguments("static abstract members in interfaces").WithLocation(1, 10)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.ConversionOperatorDeclaration);
+                        {
+                            N(SyntaxKind.ExplicitKeyword);
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                N(SyntaxKind.DotToken);
+                            }
+                            M(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_14()
+        {
+            var errors = new[] {
+                // (1,14): error CS1003: Syntax error, '.' expected
+                // implicit N.I operator int(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 14)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("implicit N.I operator int(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,10): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // implicit N.I operator int(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "N.I ").WithArguments("static abstract members in interfaces").WithLocation(1, 10)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.ConversionOperatorDeclaration);
+                        {
+                            N(SyntaxKind.ImplicitKeyword);
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.QualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N");
+                                    }
+                                    N(SyntaxKind.DotToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "I");
+                                    }
+                                }
+                                M(SyntaxKind.DotToken);
+                            }
+                            N(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_15()
+        {
+            var errors = new[] {
+                // (1,12): error CS1003: Syntax error, '.' expected
+                // explicit I operator int(int x) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(".", "operator").WithLocation(1, 12)
+                };
+
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                foreach (var version in new[] { LanguageVersion.CSharp9, LanguageVersion.Preview })
+                {
+                    UsingTree("explicit I operator int(int x) => x;", options: options.WithLanguageVersion(version),
+                        version == LanguageVersion.CSharp9 ?
+                            errors.Append(
+                                // (1,10): error CS8652: The feature 'static abstract members in interfaces' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                                // explicit I operator int(int x) => x;
+                                Diagnostic(ErrorCode.ERR_FeatureInPreview, "I ").WithArguments("static abstract members in interfaces").WithLocation(1, 10)
+                                ).ToArray() :
+                            errors);
+
+                    N(SyntaxKind.CompilationUnit);
+                    {
+                        N(SyntaxKind.ConversionOperatorDeclaration);
+                        {
+                            N(SyntaxKind.ExplicitKeyword);
+                            N(SyntaxKind.ExplicitInterfaceSpecifier);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                                M(SyntaxKind.DotToken);
+                            }
+                            N(SyntaxKind.OperatorKeyword);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.ParameterList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                            N(SyntaxKind.ArrowExpressionClause);
+                            {
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.EndOfFileToken);
+                    }
+                    EOF();
+                }
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_16()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("implicit N::I::operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,14): error CS7000: Unexpected use of an aliased name
+                    // implicit N::I::operator int(int x) => x;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 14)
+                    );
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        N(SyntaxKind.ImplicitKeyword);
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.AliasQualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.ColonColonToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_17()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("explicit I::operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,11): error CS0687: The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead.
+                    // explicit I::operator int(int x) => x;
+                    Diagnostic(ErrorCode.ERR_AliasQualAsExpression, "::").WithLocation(1, 11)
+                    );
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        N(SyntaxKind.ExplicitKeyword);
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            M(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_18()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("implicit I.operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        N(SyntaxKind.ImplicitKeyword);
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_19()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("explicit I<T>.operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview));
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        N(SyntaxKind.ExplicitKeyword);
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.GenericName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                                N(SyntaxKind.TypeArgumentList);
+                                {
+                                    N(SyntaxKind.LessThanToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "T");
+                                    }
+                                    N(SyntaxKind.GreaterThanToken);
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_20()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingTree("implicit N1::N2::I.operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,16): error CS7000: Unexpected use of an aliased name
+                    // implicit N1::N2::I.operator int(int x) => x;
+                    Diagnostic(ErrorCode.ERR_UnexpectedAliasedName, "::").WithLocation(1, 16)
+                    );
+
+                N(SyntaxKind.CompilationUnit);
+                {
+                    N(SyntaxKind.ConversionOperatorDeclaration);
+                    {
+                        N(SyntaxKind.ImplicitKeyword);
+                        N(SyntaxKind.ExplicitInterfaceSpecifier);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.AliasQualifiedName);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N1");
+                                    }
+                                    N(SyntaxKind.ColonColonToken);
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "N2");
+                                    }
+                                }
+                                M(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                        }
+                        N(SyntaxKind.OperatorKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.Parameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.IntKeyword);
+                                }
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.ArrowExpressionClause);
+                        {
+                            N(SyntaxKind.EqualsGreaterThanToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                    N(SyntaxKind.EndOfFileToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_21()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I..operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,12): error CS1001: Identifier expected
+                    // explicit I..operator int(int x) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ".operato").WithLocation(1, 12)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_22()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("implicit I . . operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,14): error CS1001: Identifier expected
+                    // implicit I . . operator int(int x) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ".").WithLocation(1, 14)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ImplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_23()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I T(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,12): error CS1003: Syntax error, '.' expected
+                    // explicit I T(int x) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "T").WithArguments(".", "").WithLocation(1, 12),
+                    // (1,12): error CS1003: Syntax error, 'operator' expected
+                    // explicit I T(int x) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "T").WithArguments("operator", "").WithLocation(1, 12)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        M(SyntaxKind.DotToken);
+                    }
+                    M(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_24()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.T(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,12): error CS1003: Syntax error, 'operator' expected
+                    // explicit I.T(int x) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "T").WithArguments("operator", "").WithLocation(1, 12)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    M(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T");
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_25()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.operator (int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,21): error CS1001: Identifier expected
+                    // explicit I.operator (int x) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(1, 21)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_26()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.operator (int x) { return x; }", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,21): error CS1001: Identifier expected
+                    // explicit I.operator (int x) { return x; }
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(1, 21)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.Block);
+                    {
+                        N(SyntaxKind.OpenBraceToken);
+                        N(SyntaxKind.ReturnStatement);
+                        {
+                            N(SyntaxKind.ReturnKeyword);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            N(SyntaxKind.SemicolonToken);
+                        }
+                        N(SyntaxKind.CloseBraceToken);
+                    }
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_27()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.operator (int x);", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,21): error CS1001: Identifier expected
+                    // explicit I.operator (int x);
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(1, 21)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_28()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.T1 T2(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,15): error CS1003: Syntax error, '.' expected
+                    // explicit I.T1 T2(int x) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "T2").WithArguments(".", "").WithLocation(1, 15),
+                    // (1,15): error CS1003: Syntax error, 'operator' expected
+                    // explicit I.T1 T2(int x) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "T2").WithArguments("operator", "").WithLocation(1, 15)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "I");
+                            }
+                            N(SyntaxKind.DotToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "T1");
+                            }
+                        }
+                        M(SyntaxKind.DotToken);
+                    }
+                    M(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "T2");
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_29()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.operator (int x)", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,21): error CS1001: Identifier expected
+                    // explicit I.operator (int x)
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(1, 21),
+                    // (1,28): error CS1002: ; expected
+                    // explicit I.operator (int x)
+                    Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(1, 28)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    M(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_30()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.operator (int x, );", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,29): error CS1031: Type expected
+                    // explicit I.operator (int x, );
+                    Diagnostic(ErrorCode.ERR_TypeExpected, ")").WithLocation(1, 29),
+                    // (1,30): error CS1003: Syntax error, '(' expected
+                    // explicit I.operator (int x, );
+                    Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("(", ";").WithLocation(1, 30),
+                    // (1,30): error CS1026: ) expected
+                    // explicit I.operator (int x, );
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, ";").WithLocation(1, 30)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.TupleType);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.TupleElement);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CommaToken);
+                        M(SyntaxKind.TupleElement);
+                        {
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    M(SyntaxKind.ParameterList);
+                    {
+                        M(SyntaxKind.OpenParenToken);
+                        M(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_31()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.operator (int x, int y);", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,35): error CS1003: Syntax error, '(' expected
+                    // explicit I.operator (int x, int y);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("(", ";").WithLocation(1, 35),
+                    // (1,35): error CS1026: ) expected
+                    // explicit I.operator (int x, int y);
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, ";").WithLocation(1, 35)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.TupleType);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.TupleElement);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.TupleElement);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "y");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    M(SyntaxKind.ParameterList);
+                    {
+                        M(SyntaxKind.OpenParenToken);
+                        M(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_32()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.operator var(x);", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,26): error CS1001: Identifier expected
+                    // explicit I.operator var(x);
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 26)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "var");
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "x");
+                            }
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_33()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit I.operator (int x int y);", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,21): error CS1001: Identifier expected
+                    // explicit I.operator (int x int y);
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(1, 21),
+                    // (1,28): error CS1003: Syntax error, ',' expected
+                    // explicit I.operator (int x int y);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "int").WithArguments(",", "int").WithLocation(1, 28)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "I");
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "y");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_34()
+        {
+            foreach (var options in new[] { TestOptions.Script, TestOptions.Regular })
+            {
+                UsingDeclaration("explicit N.I..operator int(int x) => x;", options: options.WithLanguageVersion(LanguageVersion.Preview),
+                    // (1,14): error CS1001: Identifier expected
+                    // explicit N.I..operator int(int x) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ".operato").WithLocation(1, 14)
+                    );
+
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    N(SyntaxKind.ExplicitInterfaceSpecifier);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.QualifiedName);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "N");
+                                }
+                                N(SyntaxKind.DotToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "I");
+                                }
+                            }
+                            N(SyntaxKind.DotToken);
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                    }
+                    N(SyntaxKind.OperatorKeyword);
+                    N(SyntaxKind.PredefinedType);
+                    {
+                        N(SyntaxKind.IntKeyword);
+                    }
+                    N(SyntaxKind.ParameterList);
+                    {
+                        N(SyntaxKind.OpenParenToken);
+                        N(SyntaxKind.Parameter);
+                        {
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.IntKeyword);
+                            }
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                        N(SyntaxKind.CloseParenToken);
+                    }
+                    N(SyntaxKind.ArrowExpressionClause);
+                    {
+                        N(SyntaxKind.EqualsGreaterThanToken);
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "x");
+                        }
+                    }
+                    N(SyntaxKind.SemicolonToken);
+                }
+                EOF();
+            }
+        }
+
+        [Fact]
+        public void ConversionDeclaration_ExplicitImplementation_35()
+        {
+            var error = new[] {
+                // (2,9): error CS1003: Syntax error, 'operator' expected
+                // explicit
+                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("operator", "").WithLocation(2, 9),
+                // (2,9): error CS1001: Identifier expected
+                // explicit
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(2, 9)
+                };
+
+            UsingTree(
+@"
+explicit
+Func<int, int> f1 = (param1) => 10;
+", options: TestOptions.Regular, error);
+
+            N(SyntaxKind.CompilationUnit);
+            {
+                N(SyntaxKind.ConversionOperatorDeclaration);
+                {
+                    N(SyntaxKind.ExplicitKeyword);
+                    M(SyntaxKind.OperatorKeyword);
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    M(SyntaxKind.ParameterList);
+                    {
+                        M(SyntaxKind.OpenParenToken);
+                        M(SyntaxKind.CloseParenToken);
+                    }
+                    M(SyntaxKind.SemicolonToken);
+                }
+                N(SyntaxKind.GlobalStatement);
+                {
+                    N(SyntaxKind.LocalDeclarationStatement);
+                    {
+                        N(SyntaxKind.VariableDeclaration);
+                        {
+                            N(SyntaxKind.GenericName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Func");
+                                N(SyntaxKind.TypeArgumentList);
+                                {
+                                    N(SyntaxKind.LessThanToken);
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.CommaToken);
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.IntKeyword);
+                                    }
+                                    N(SyntaxKind.GreaterThanToken);
+                                }
+                            }
+                            N(SyntaxKind.VariableDeclarator);
+                            {
+                                N(SyntaxKind.IdentifierToken, "f1");
+                                N(SyntaxKind.EqualsValueClause);
+                                {
+                                    N(SyntaxKind.EqualsToken);
+                                    N(SyntaxKind.ParenthesizedLambdaExpression);
+                                    {
+                                        N(SyntaxKind.ParameterList);
+                                        {
+                                            N(SyntaxKind.OpenParenToken);
+                                            N(SyntaxKind.Parameter);
+                                            {
+                                                N(SyntaxKind.IdentifierToken, "param1");
+                                            }
+                                            N(SyntaxKind.CloseParenToken);
+                                        }
+                                        N(SyntaxKind.EqualsGreaterThanToken);
+                                        N(SyntaxKind.NumericLiteralExpression);
+                                        {
+                                            N(SyntaxKind.NumericLiteralToken, "10");
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                }
+                N(SyntaxKind.EndOfFileToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void DotDotRecovery_01()
+        {
+            UsingDeclaration("N1..N2 M(int x) => x;", options: TestOptions.Regular,
+                // (1,4): error CS1001: Identifier expected
+                // N1..N2 M(int x) => x;
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, ".").WithLocation(1, 4)
+                );
+
+            N(SyntaxKind.MethodDeclaration);
+            {
+                N(SyntaxKind.QualifiedName);
+                {
+                    N(SyntaxKind.QualifiedName);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "N1");
+                        }
+                        N(SyntaxKind.DotToken);
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    N(SyntaxKind.DotToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "N2");
+                    }
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.ArrowExpressionClause);
+                {
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void DotDotRecovery_02()
+        {
+            UsingDeclaration("int N1..M(int x) => x;", options: TestOptions.Regular,
+                // (1,8): error CS1001: Identifier expected
+                // int N1..M(int x) => x;
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, ".").WithLocation(1, 8)
+                );
+
+            N(SyntaxKind.MethodDeclaration);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.IntKeyword);
+                }
+                N(SyntaxKind.ExplicitInterfaceSpecifier);
+                {
+                    N(SyntaxKind.QualifiedName);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "N1");
+                        }
+                        N(SyntaxKind.DotToken);
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    N(SyntaxKind.DotToken);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.ArrowExpressionClause);
+                {
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void DotDotRecovery_03()
+        {
+            UsingDeclaration("int N1.N2..M(int x) => x;", options: TestOptions.Regular,
+                // (1,11): error CS1001: Identifier expected
+                // int N1.N2..M(int x) => x;
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, ".").WithLocation(1, 11)
+                );
+
+            N(SyntaxKind.MethodDeclaration);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.IntKeyword);
+                }
+                N(SyntaxKind.ExplicitInterfaceSpecifier);
+                {
+                    N(SyntaxKind.QualifiedName);
+                    {
+                        N(SyntaxKind.QualifiedName);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "N1");
+                            }
+                            N(SyntaxKind.DotToken);
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "N2");
+                            }
+                        }
+                        N(SyntaxKind.DotToken);
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    N(SyntaxKind.DotToken);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.IntKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.ArrowExpressionClause);
+                {
+                    N(SyntaxKind.EqualsGreaterThanToken);
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "x");
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/ParserErrorMessageTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/ParserErrorMessageTests.cs
index 6d651a3a88adc..9710e38fb52e1 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/ParserErrorMessageTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/ParserErrorMessageTests.cs
@@ -2886,12 +2886,9 @@ public static A operator ()
                 // (4,43): error CS1003: Syntax error, ',' expected
                 //     public static int explicit operator ()
                 Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",", "{").WithLocation(4, 43),
-                // (6,18): error CS1026: ) expected
+                // (6,17): error CS1026: ) expected
                 //         return 0;
-                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(6, 18),
-                // (6,18): error CS1002: ; expected
-                //         return 0;
-                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(6, 18),
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, ";").WithLocation(6, 17),
                 // (8,30): error CS1037: Overloadable operator expected
                 //     public static A operator ()
                 Diagnostic(ErrorCode.ERR_OvlOperatorExpected, "(").WithLocation(8, 30),
@@ -2947,12 +2944,9 @@ public static A operator ()
                 // (4,43): error CS1003: Syntax error, ',' expected
                 //     public static int explicit operator ()
                 Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",", "{").WithLocation(4, 43),
-                // (6,18): error CS1026: ) expected
-                //         return 0;
-                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(6, 18),
-                // (6,18): error CS1002: ; expected
+                // (6,17): error CS1026: ) expected
                 //         return 0;
-                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(6, 18),
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, ";").WithLocation(6, 17),
                 // (8,30): error CS1037: Overloadable operator expected
                 //     public static A operator ()
                 Diagnostic(ErrorCode.ERR_OvlOperatorExpected, "(").WithLocation(8, 30),
@@ -4650,12 +4644,9 @@ public static int Main ()
                 // (3,49): error CS1003: Syntax error, ',' expected
                 //     public static int implicit operator (goo f) { return 6; }    // Error
                 Diagnostic(ErrorCode.ERR_SyntaxError, "{").WithArguments(",", "{").WithLocation(3, 49),
-                // (3,61): error CS1026: ) expected
+                // (3,59): error CS1026: ) expected
                 //     public static int implicit operator (goo f) { return 6; }    // Error
-                Diagnostic(ErrorCode.ERR_CloseParenExpected, "}").WithLocation(3, 61),
-                // (3,61): error CS1002: ; expected
-                //     public static int implicit operator (goo f) { return 6; }    // Error
-                Diagnostic(ErrorCode.ERR_SemicolonExpected, "}").WithLocation(3, 61),
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, ";").WithLocation(3, 59),
                 // (4,1): error CS1022: Type or namespace definition, or end-of-file expected
                 // }
                 Diagnostic(ErrorCode.ERR_EOFExpected, "}").WithLocation(4, 1)
@@ -4707,12 +4698,9 @@ public static int Main ()
                 // (3,49): error CS1003: Syntax error, ',' expected
                 //     public static int implicit operator (goo f) { return 6; }    // Error
                 Diagnostic(ErrorCode.ERR_SyntaxError, "{").WithArguments(",", "{").WithLocation(3, 49),
-                // (3,61): error CS1026: ) expected
-                //     public static int implicit operator (goo f) { return 6; }    // Error
-                Diagnostic(ErrorCode.ERR_CloseParenExpected, "}").WithLocation(3, 61),
-                // (3,61): error CS1002: ; expected
+                // (3,59): error CS1026: ) expected
                 //     public static int implicit operator (goo f) { return 6; }    // Error
-                Diagnostic(ErrorCode.ERR_SemicolonExpected, "}").WithLocation(3, 61),
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, ";").WithLocation(3, 59),
                 // (4,1): error CS1022: Type or namespace definition, or end-of-file expected
                 // }
                 Diagnostic(ErrorCode.ERR_EOFExpected, "}").WithLocation(4, 1)
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/ParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/ParsingTests.cs
index 8f430d1182bfc..17f180d628916 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/ParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/ParsingTests.cs
@@ -93,10 +93,7 @@ internal void UsingStatement(string text, params DiagnosticDescription[] expecte
         internal void UsingStatement(string text, ParseOptions? options, params DiagnosticDescription[] expectedErrors)
         {
             var node = SyntaxFactory.ParseStatement(text, options: options);
-            // we validate the text roundtrips
-            Assert.Equal(text, node.ToFullString());
-            var actualErrors = node.GetDiagnostics();
-            actualErrors.Verify(expectedErrors);
+            Validate(text, node, expectedErrors);
             UsingNode(node);
         }
 
@@ -126,12 +123,17 @@ internal void UsingExpression(string text, ParseOptions? options, params Diagnos
         }
 
         protected void UsingNode(string text, CSharpSyntaxNode node, DiagnosticDescription[] expectedErrors)
+        {
+            Validate(text, node, expectedErrors);
+            UsingNode(node);
+        }
+
+        protected void Validate(string text, CSharpSyntaxNode node, params DiagnosticDescription[] expectedErrors)
         {
             // we validate the text roundtrips
             Assert.Equal(text, node.ToFullString());
             var actualErrors = node.GetDiagnostics();
             actualErrors.Verify(expectedErrors);
-            UsingNode(node);
         }
 
         internal void UsingExpression(string text, params DiagnosticDescription[] expectedErrors)
@@ -190,15 +192,17 @@ protected SyntaxNodeOrToken N(SyntaxKind kind, string? value = null)
             try
             {
                 Assert.True(_treeEnumerator!.MoveNext());
-                Assert.Equal(kind, _treeEnumerator.Current.Kind());
-                Assert.False(_treeEnumerator.Current.IsMissing);
+                var current = _treeEnumerator.Current;
+
+                Assert.Equal(kind, current.Kind());
+                Assert.False(current.IsMissing);
 
                 if (value != null)
                 {
-                    Assert.Equal(_treeEnumerator.Current.ToString(), value);
+                    Assert.Equal(current.ToString(), value);
                 }
 
-                return _treeEnumerator.Current;
+                return current;
             }
             catch when (DumpAndCleanup())
             {
@@ -286,11 +290,13 @@ private void Print(SyntaxNodeOrToken node, bool dump)
                 {
                     case SyntaxKind.IdentifierToken:
                     case SyntaxKind.NumericLiteralToken:
+                    case SyntaxKind.StringLiteralToken:
                         if (node.IsMissing)
                         {
                             goto default;
                         }
-                        _output.WriteLine(@"N(SyntaxKind.{0}, ""{1}"");", node.Kind(), node.ToString());
+                        var value = node.ToString().Replace("\"", "\\\"");
+                        _output.WriteLine(@"N(SyntaxKind.{0}, ""{1}"");", node.Kind(), value);
                         break;
                     default:
                         _output.WriteLine("{0}(SyntaxKind.{1});", node.IsMissing ? "M" : "N", node.Kind());
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/PatternParsingTests2.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/PatternParsingTests2.cs
index c5ad3311d7edb..646d55b54b899 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/PatternParsingTests2.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/PatternParsingTests2.cs
@@ -24,13 +24,13 @@ public PatternParsingTests2(ITestOutputHelper output) : base(output)
         [Fact]
         public void ExtendedPropertySubpattern_01()
         {
-            UsingExpression(@"e is { a.b.c: p }");
+            UsingExpression(@"e is { a.b.c: p }", TestOptions.Regular10);
             verify();
 
             UsingExpression(@"e is { a.b.c: p }", TestOptions.Regular9,
-                    // (1,8): error CS8652: The feature 'extended property patterns' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                    // e is { a.b.c: p }
-                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "a.b.c").WithArguments("extended property patterns").WithLocation(1, 8));
+                // (1,8): error CS8773: Feature 'extended property patterns' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // e is { a.b.c: p }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "a.b.c").WithArguments("extended property patterns", "10.0").WithLocation(1, 8));
             verify();
 
             void verify()
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/RecordParsing.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/RecordParsing.cs
index 8a41b481ea4bf..112b273c84e92 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/RecordParsing.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/RecordParsing.cs
@@ -2600,16 +2600,16 @@ public void RecordStructParsing_RecordNamedStruct()
         {
             var text = "record struct(int X, int Y);";
             UsingTree(text, options: TestOptions.Regular9,
-                // (1,8): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,8): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record struct(int X, int Y);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "struct").WithArguments("record structs").WithLocation(1, 8),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(1, 8),
                 // (1,14): error CS1001: Identifier expected
                 // record struct(int X, int Y);
                 Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(1, 14)
                 );
             verify();
 
-            UsingTree(text, options: TestOptions.RegularPreview,
+            UsingTree(text, options: TestOptions.Regular10,
                 // (1,14): error CS1001: Identifier expected
                 // record struct(int X, int Y);
                 Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(1, 14)
@@ -2659,14 +2659,14 @@ void verify()
         public void RecordStructParsing()
         {
             var text = "record struct C(int X, int Y);";
-            UsingTree(text, options: TestOptions.RegularPreview);
+            UsingTree(text, options: TestOptions.Regular10);
 
             verifyParsedAsRecord();
 
             UsingTree(text, options: TestOptions.Regular9,
-                 // (1,8): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
-                 // record struct C(int X, int Y);
-                 Diagnostic(ErrorCode.ERR_FeatureInPreview, "struct").WithArguments("record structs").WithLocation(1, 8)
+                // (1,8): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // record struct C(int X, int Y);
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(1, 8)
                  );
 
             verifyParsedAsRecord();
@@ -2793,7 +2793,7 @@ void verifyParsedAsRecord()
         public void RecordStructParsing_WithBody()
         {
             var text = "record struct C(int X, int Y) { }";
-            UsingTree(text, options: TestOptions.RegularPreview);
+            UsingTree(text, options: TestOptions.Regular10);
 
             N(SyntaxKind.CompilationUnit);
             {
@@ -2836,14 +2836,14 @@ public void RecordStructParsing_WithBody()
         public void RecordClassParsing()
         {
             var text = "record class C(int X, int Y);";
-            UsingTree(text, options: TestOptions.RegularPreview);
+            UsingTree(text, options: TestOptions.Regular10);
 
             verifyParsedAsRecord();
 
             UsingTree(text, options: TestOptions.Regular9,
-                // (1,8): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,8): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // record class C(int X, int Y);
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "class").WithArguments("record structs").WithLocation(1, 8)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "class").WithArguments("record structs", "10.0").WithLocation(1, 8)
                 );
 
             verifyParsedAsRecord();
@@ -3727,9 +3727,9 @@ public void RecordStructParsing_Ref()
             EOF();
 
             UsingTree(text, options: TestOptions.Regular9,
-                // (1,12): error CS8652: The feature 'record structs' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,12): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // ref record struct S;
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "struct").WithArguments("record structs").WithLocation(1, 12)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(1, 12)
                 );
 
             verifyParsedAsRecord();
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/ScriptParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/ScriptParsingTests.cs
index 93d5b99c954fb..c1655b314028c 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/ScriptParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/ScriptParsingTests.cs
@@ -1680,8 +1680,9 @@ public void Error_IndexerDefinition()
             ParseAndValidate(test,
                 new ErrorDescription { Code = 1001, Line = 1, Column = 13 },
                 new ErrorDescription { Code = 1003, Line = 1, Column = 13 },
-                new ErrorDescription { Code = 1003, Line = 1, Column = 17 },
-                new ErrorDescription { Code = 1514, Line = 1, Column = 17 },
+                new ErrorDescription { Code = 1003, Line = 1, Column = 16 },
+                new ErrorDescription { Code = 1514, Line = 1, Column = 16 },
+                new ErrorDescription { Code = 1014, Line = 1, Column = 16 },
                 new ErrorDescription { Code = 1513, Line = 1, Column = 17 });
 
             CreateCompilation(test).VerifyDiagnostics(
@@ -1691,12 +1692,15 @@ public void Error_IndexerDefinition()
                 // (1,13): error CS1001: Identifier expected
                 // string this ="";
                 Diagnostic(ErrorCode.ERR_IdentifierExpected, "=").WithLocation(1, 13),
-                // (1,17): error CS1003: Syntax error, ']' expected
+                // (1,16): error CS1003: Syntax error, ']' expected
                 // string this ="";
-                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]", "").WithLocation(1, 17),
-                // (1,17): error CS1514: { expected
+                Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("]", ";").WithLocation(1, 16),
+                // (1,16): error CS1514: { expected
                 // string this ="";
-                Diagnostic(ErrorCode.ERR_LbraceExpected, "").WithLocation(1, 17),
+                Diagnostic(ErrorCode.ERR_LbraceExpected, ";").WithLocation(1, 16),
+                // (1,16): error CS1014: A get or set accessor expected
+                // string this ="";
+                Diagnostic(ErrorCode.ERR_GetOrSetExpected, ";").WithLocation(1, 16),
                 // (1,17): error CS1513: } expected
                 // string this ="";
                 Diagnostic(ErrorCode.ERR_RbraceExpected, "").WithLocation(1, 17),
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/TopLevelStatementsParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/TopLevelStatementsParsingTests.cs
index 6e19aea99dcec..a829a2b420bb7 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/TopLevelStatementsParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/TopLevelStatementsParsingTests.cs
@@ -17,11 +17,6 @@ public sealed class TopLevelStatementsParsingTests : ParsingTests
     {
         public TopLevelStatementsParsingTests(ITestOutputHelper output) : base(output) { }
 
-        protected override SyntaxTree ParseTree(string text, CSharpParseOptions options)
-        {
-            return SyntaxFactory.ParseSyntaxTree(text, options: options ?? TestOptions.Regular9);
-        }
-
         private SyntaxTree UsingTree(string text, params DiagnosticDescription[] expectedErrors)
         {
             var tree = base.UsingTree(text);
@@ -2587,5 +2582,70 @@ public void ConstructorLike_03()
             }
             EOF();
         }
+
+        [Fact]
+        public void UsingAliasTest()
+        {
+            var test = @"using s = delegate*<void>;";
+
+            UsingTree(test,
+                // (1,11): error CS1041: Identifier expected; 'delegate' is a keyword
+                // using s = delegate*<void>;
+                Diagnostic(ErrorCode.ERR_IdentifierExpectedKW, "delegate").WithArguments("", "delegate").WithLocation(1, 11),
+                // (1,25): error CS0116: A namespace cannot directly contain members such as fields or methods
+                // using s = delegate*<void>;
+                Diagnostic(ErrorCode.ERR_NamespaceUnexpected, ">").WithLocation(1, 25)
+                );
+
+            N(SyntaxKind.CompilationUnit);
+            {
+                N(SyntaxKind.UsingDirective);
+                {
+                    N(SyntaxKind.UsingKeyword);
+                    N(SyntaxKind.NameEquals);
+                    {
+                        N(SyntaxKind.IdentifierName);
+                        {
+                            N(SyntaxKind.IdentifierToken, "s");
+                        }
+                        N(SyntaxKind.EqualsToken);
+                    }
+                    M(SyntaxKind.IdentifierName);
+                    {
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    M(SyntaxKind.SemicolonToken);
+                }
+                N(SyntaxKind.IncompleteMember);
+                {
+                    N(SyntaxKind.FunctionPointerType);
+                    {
+                        N(SyntaxKind.DelegateKeyword);
+                        N(SyntaxKind.AsteriskToken);
+                        N(SyntaxKind.FunctionPointerParameterList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.FunctionPointerParameter);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.VoidKeyword);
+                                }
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                }
+                N(SyntaxKind.GlobalStatement);
+                {
+                    N(SyntaxKind.EmptyStatement);
+                    {
+                        N(SyntaxKind.SemicolonToken);
+                    }
+                }
+                N(SyntaxKind.EndOfFileToken);
+            }
+            EOF();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxTreeTests.cs b/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxTreeTests.cs
index 806ada148b529..0b84004d50a4e 100644
--- a/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxTreeTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxTreeTests.cs
@@ -248,7 +248,7 @@ public void GlobalUsingDirective_01()
         {
             var test = "global using ns1;";
 
-            UsingTree(test, TestOptions.RegularPreview);
+            UsingTree(test, TestOptions.Regular10);
 
             N(SyntaxKind.CompilationUnit);
             {
@@ -273,9 +273,9 @@ public void GlobalUsingDirective_02()
             var test = "global using ns1;";
 
             UsingTree(test, TestOptions.Regular9,
-                // (1,1): error CS8652: The feature 'global using directive' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,1): error CS8773: Feature 'global using directive' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // global using ns1;
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "global using ns1;").WithArguments("global using directive").WithLocation(1, 1)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "global using ns1;").WithArguments("global using directive", "10.0").WithLocation(1, 1)
                 );
 
             N(SyntaxKind.CompilationUnit);
@@ -300,7 +300,7 @@ public void GlobalUsingDirective_03()
         {
             var test = "namespace ns { global using ns1; }";
 
-            UsingTree(test, TestOptions.RegularPreview);
+            UsingTree(test, TestOptions.Regular10);
 
             N(SyntaxKind.CompilationUnit);
             {
@@ -335,9 +335,9 @@ public void GlobalUsingDirective_04()
             var test = "namespace ns { global using ns1; }";
 
             UsingTree(test, TestOptions.Regular9,
-                // (1,16): error CS8652: The feature 'global using directive' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,16): error CS8773: Feature 'global using directive' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // namespace ns { global using ns1; }
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "global using ns1;").WithArguments("global using directive").WithLocation(1, 16)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "global using ns1;").WithArguments("global using directive", "10.0").WithLocation(1, 16)
                 );
 
             N(SyntaxKind.CompilationUnit);
@@ -372,7 +372,7 @@ public void GlobalUsingDirective_05()
         {
             var test = "global using static ns1;";
 
-            UsingTree(test, TestOptions.RegularPreview);
+            UsingTree(test, TestOptions.Regular10);
 
             N(SyntaxKind.CompilationUnit);
             {
@@ -398,9 +398,9 @@ public void GlobalUsingDirective_06()
             var test = "global using static ns1;";
 
             UsingTree(test, TestOptions.Regular9,
-                // (1,1): error CS8652: The feature 'global using directive' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,1): error CS8773: Feature 'global using directive' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // global using static ns1;
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "global using static ns1;").WithArguments("global using directive").WithLocation(1, 1)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "global using static ns1;").WithArguments("global using directive", "10.0").WithLocation(1, 1)
                 );
 
             N(SyntaxKind.CompilationUnit);
@@ -426,7 +426,7 @@ public void GlobalUsingDirective_07()
         {
             var test = "namespace ns { global using static ns1; }";
 
-            UsingTree(test, TestOptions.RegularPreview);
+            UsingTree(test, TestOptions.Regular10);
 
             N(SyntaxKind.CompilationUnit);
             {
@@ -462,9 +462,9 @@ public void GlobalUsingDirective_08()
             var test = "namespace ns { global using static ns1; }";
 
             UsingTree(test, TestOptions.Regular9,
-                // (1,16): error CS8652: The feature 'global using directive' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,16): error CS8773: Feature 'global using directive' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // namespace ns { global using static ns1; }
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "global using static ns1;").WithArguments("global using directive").WithLocation(1, 16)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "global using static ns1;").WithArguments("global using directive", "10.0").WithLocation(1, 16)
                 );
 
             N(SyntaxKind.CompilationUnit);
@@ -533,9 +533,9 @@ public void GlobalUsingDirective_10()
             var test = "global using alias = ns1;";
 
             UsingTree(test, TestOptions.Regular9,
-                // (1,1): error CS8652: The feature 'global using directive' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,1): error CS8773: Feature 'global using directive' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // global using alias = ns1;
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "global using alias = ns1;").WithArguments("global using directive").WithLocation(1, 1)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "global using alias = ns1;").WithArguments("global using directive", "10.0").WithLocation(1, 1)
                 );
 
             N(SyntaxKind.CompilationUnit);
@@ -611,9 +611,9 @@ public void GlobalUsingDirective_12()
             var test = "namespace ns { global using alias = ns1; }";
 
             UsingTree(test, TestOptions.Regular9,
-                // (1,16): error CS8652: The feature 'global using directive' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                // (1,16): error CS8773: Feature 'global using directive' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // namespace ns { global using alias = ns1; }
-                Diagnostic(ErrorCode.ERR_FeatureInPreview, "global using alias = ns1;").WithArguments("global using directive").WithLocation(1, 16)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "global using alias = ns1;").WithArguments("global using directive", "10.0").WithLocation(1, 16)
                 );
 
             N(SyntaxKind.CompilationUnit);
diff --git a/src/Compilers/Core/CodeAnalysisTest/Analyzers/AnalyzerFileReferenceTests.cs b/src/Compilers/Core/CodeAnalysisTest/Analyzers/AnalyzerFileReferenceTests.cs
index 79769dc19af09..6e25a7ef485ad 100644
--- a/src/Compilers/Core/CodeAnalysisTest/Analyzers/AnalyzerFileReferenceTests.cs
+++ b/src/Compilers/Core/CodeAnalysisTest/Analyzers/AnalyzerFileReferenceTests.cs
@@ -253,7 +253,7 @@ public void TestLoadGenerators()
         {
             AnalyzerFileReference reference = CreateAnalyzerFileReference(Assembly.GetExecutingAssembly().Location);
             var generators = reference.GetGeneratorsForAllLanguages();
-            var typeNames = generators.Select(g => g.GetType().FullName);
+            var typeNames = generators.Select(g => g.GetGeneratorType().FullName);
 
             AssertEx.SetEqual(new[]
             {
@@ -266,7 +266,9 @@ public void TestLoadGenerators()
                 "Microsoft.CodeAnalysis.UnitTests.VisualBasicOnlyGenerator",
                 "Microsoft.CodeAnalysis.UnitTests.CSharpAndVisualBasicGenerator",
                 "Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator",
-                "Microsoft.CodeAnalysis.UnitTests.FSharpGenerator"
+                "Microsoft.CodeAnalysis.UnitTests.FSharpGenerator",
+                "Microsoft.CodeAnalysis.UnitTests.TestSourceAndIncrementalGenerator",
+                "Microsoft.CodeAnalysis.UnitTests.TestIncrementalGenerator"
             }, typeNames);
         }
 
@@ -289,7 +291,7 @@ public void TestLoadCSharpGenerators()
             AnalyzerFileReference reference = CreateAnalyzerFileReference(Assembly.GetExecutingAssembly().Location);
             var generators = reference.GetGenerators(LanguageNames.CSharp);
 
-            var typeNames = generators.Select(g => g.GetType().FullName);
+            var typeNames = generators.Select(g => g.GetGeneratorType().FullName);
             AssertEx.SetEqual(new[]
             {
                 "Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+TestGenerator",
@@ -299,7 +301,9 @@ public void TestLoadCSharpGenerators()
                 "Microsoft.CodeAnalysis.UnitTests.SubClassedGenerator",
                 "Microsoft.CodeAnalysis.UnitTests.ExplicitCSharpOnlyGenerator",
                 "Microsoft.CodeAnalysis.UnitTests.CSharpAndVisualBasicGenerator",
-                "Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator"
+                "Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator",
+                "Microsoft.CodeAnalysis.UnitTests.TestSourceAndIncrementalGenerator",
+                "Microsoft.CodeAnalysis.UnitTests.TestIncrementalGenerator"
             }, typeNames);
         }
 
@@ -309,12 +313,14 @@ public void TestLoadVisualBasicGenerators()
             AnalyzerFileReference reference = CreateAnalyzerFileReference(Assembly.GetExecutingAssembly().Location);
             var generators = reference.GetGenerators(LanguageNames.VisualBasic);
 
-            var typeNames = generators.Select(g => g.GetType().FullName);
+            var typeNames = generators.Select(g => g.GetGeneratorType().FullName);
             AssertEx.SetEqual(new[]
             {
                 "Microsoft.CodeAnalysis.UnitTests.VisualBasicOnlyGenerator",
                 "Microsoft.CodeAnalysis.UnitTests.CSharpAndVisualBasicGenerator",
-                "Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator"
+                "Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator",
+                "Microsoft.CodeAnalysis.UnitTests.TestSourceAndIncrementalGenerator",
+                "Microsoft.CodeAnalysis.UnitTests.TestIncrementalGenerator"
             }, typeNames);
         }
 
@@ -430,8 +436,8 @@ public void TestLoadedGeneratorOrderIsDeterministic()
         {
             AnalyzerFileReference reference = CreateAnalyzerFileReference(Assembly.GetExecutingAssembly().Location);
 
-            var csharpGenerators = reference.GetGenerators(LanguageNames.CSharp).Select(a => a.GetType().FullName).ToArray();
-            Assert.Equal(8, csharpGenerators.Length);
+            var csharpGenerators = reference.GetGenerators(LanguageNames.CSharp).Select(g => g.GetGeneratorType().FullName).ToArray();
+            Assert.Equal(10, csharpGenerators.Length);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+SomeType+NestedGenerator", csharpGenerators[0]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+TestGenerator", csharpGenerators[1]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.BaseGenerator", csharpGenerators[2]);
@@ -439,17 +445,21 @@ public void TestLoadedGeneratorOrderIsDeterministic()
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.ExplicitCSharpOnlyGenerator", csharpGenerators[4]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.SubClassedGenerator", csharpGenerators[5]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestGenerator", csharpGenerators[6]);
-            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator", csharpGenerators[7]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestIncrementalGenerator", csharpGenerators[7]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestSourceAndIncrementalGenerator", csharpGenerators[8]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator", csharpGenerators[9]);
 
-            var vbGenerators = reference.GetGenerators(LanguageNames.VisualBasic).Select(a => a.GetType().FullName).ToArray();
-            Assert.Equal(3, vbGenerators.Length);
+            var vbGenerators = reference.GetGenerators(LanguageNames.VisualBasic).Select(g => g.GetGeneratorType().FullName).ToArray();
+            Assert.Equal(5, vbGenerators.Length);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.CSharpAndVisualBasicGenerator", vbGenerators[0]);
-            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator", vbGenerators[1]);
-            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicOnlyGenerator", vbGenerators[2]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestIncrementalGenerator", vbGenerators[1]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestSourceAndIncrementalGenerator", vbGenerators[2]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator", vbGenerators[3]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicOnlyGenerator", vbGenerators[4]);
 
             // generators load in language order (C#, F#, VB), and *do not* include duplicates
-            var allGenerators = reference.GetGeneratorsForAllLanguages().Select(g => g.GetType().FullName).ToArray();
-            Assert.Equal(10, allGenerators.Length);
+            var allGenerators = reference.GetGeneratorsForAllLanguages().Select(g => g.GetGeneratorType().FullName).ToArray();
+            Assert.Equal(12, allGenerators.Length);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+SomeType+NestedGenerator", allGenerators[0]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+TestGenerator", allGenerators[1]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.BaseGenerator", allGenerators[2]);
@@ -457,9 +467,11 @@ public void TestLoadedGeneratorOrderIsDeterministic()
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.ExplicitCSharpOnlyGenerator", allGenerators[4]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.SubClassedGenerator", allGenerators[5]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestGenerator", allGenerators[6]);
-            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator", allGenerators[7]);
-            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.FSharpGenerator", allGenerators[8]);
-            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicOnlyGenerator", allGenerators[9]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestIncrementalGenerator", allGenerators[7]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestSourceAndIncrementalGenerator", allGenerators[8]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator", allGenerators[9]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.FSharpGenerator", allGenerators[10]);
+            Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicOnlyGenerator", allGenerators[11]);
         }
 
         // NOTE: the order in which these are emitted can change the test 'TestLoadedAnalyzerOrderIsDeterministic'
@@ -597,4 +609,25 @@ public class VisualBasicAndCSharpGenerator : TestGenerator { }
 
     [Generator(LanguageNames.FSharp)]
     public class FSharpGenerator : TestGenerator { }
+
+    [Generator(LanguageNames.CSharp, LanguageNames.VisualBasic)]
+    public class TestIncrementalGenerator : IIncrementalGenerator
+    {
+        public void Initialize(IncrementalGeneratorInitializationContext context) => throw new NotImplementedException();
+    }
+
+    public class TestIncrementalGeneratorWithNoAttrib : IIncrementalGenerator
+    {
+        public void Initialize(IncrementalGeneratorInitializationContext context) => throw new NotImplementedException();
+    }
+
+    [Generator(LanguageNames.CSharp, LanguageNames.VisualBasic)]
+    public class TestSourceAndIncrementalGenerator : IIncrementalGenerator, ISourceGenerator
+    {
+        public void Execute(GeneratorExecutionContext context) => throw new NotImplementedException();
+
+        public void Initialize(IncrementalGeneratorInitializationContext context) => throw new NotImplementedException();
+
+        public void Initialize(GeneratorInitializationContext context) => throw new NotImplementedException();
+    }
 }
diff --git a/src/Compilers/Core/CodeAnalysisTest/LineMappingTests.cs b/src/Compilers/Core/CodeAnalysisTest/LineMappingTests.cs
new file mode 100644
index 0000000000000..4609e8718c291
--- /dev/null
+++ b/src/Compilers/Core/CodeAnalysisTest/LineMappingTests.cs
@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.UnitTests
+{
+    public class LineMappingTests
+    {
+        [Fact]
+        public void Equality()
+        {
+            var lineMappings = new LineMapping[]
+            {
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), hasMappedPath: true)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 2)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(2, 2)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 1), new LinePosition(1, 1)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(1, 0), new LinePosition(1, 1)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), null, new FileLinePositionSpan("file.cs", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), 0, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 2)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 0), new LinePosition(2, 2)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(0, 1), new LinePosition(1, 1)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), hasMappedPath: false)),
+                new LineMapping(new LinePositionSpan(new LinePosition(1, 0), new LinePosition(1, 1)), null, new FileLinePositionSpan("", new LinePositionSpan(new LinePosition(0, 0), new LinePosition(1, 1)), hasMappedPath: false)),
+            };
+            var equalityUnits = lineMappings.SelectMany((left, leftIndex) => lineMappings.Select((right, rightIndex) => CreateEqualityUnit(left, leftIndex, right, rightIndex))).ToArray();
+            EqualityUtil.RunAll(
+                (left, right) => left == right,
+                (left, right) => left != right,
+                equalityUnits);
+
+            static EqualityUnit<LineMapping> CreateEqualityUnit(LineMapping left, int leftIndex, LineMapping right, int rightIndex)
+            {
+                var leftUnit = EqualityUnit.Create(left);
+                return (leftIndex == rightIndex) ? leftUnit.WithEqualValues(right) : leftUnit.WithNotEqualValues(right);
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/MSBuildTask/ErrorString.resx b/src/Compilers/Core/MSBuildTask/ErrorString.resx
index 0bb6ae2d5982f..176b8cf88d829 100644
--- a/src/Compilers/Core/MSBuildTask/ErrorString.resx
+++ b/src/Compilers/Core/MSBuildTask/ErrorString.resx
@@ -214,4 +214,7 @@
   <data name="General_UnableToReadFile" xml:space="preserve">
     <value>File "{0}" could not be read: {1}</value>
   </data>
+  <data name="ImplicitlySkipAnalyzersMessage" xml:space="preserve">
+    <value>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets b/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets
index 395b63a7c7d41..674e383d829b2 100644
--- a/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets
+++ b/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets
@@ -17,6 +17,10 @@
     <_MaxSupportedLangVersion Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' AND '$(_TargetFrameworkVersionWithoutV)' == '5.0' AND
                                          '$(_MaxSupportedLangVersion)' == ''">9.0</_MaxSupportedLangVersion>
 
+    <!-- .NETCoreApp == 6.0 -->
+    <_MaxSupportedLangVersion Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' AND '$(_TargetFrameworkVersionWithoutV)' == '6.0' AND
+                                         '$(_MaxSupportedLangVersion)' == ''">10.0</_MaxSupportedLangVersion>
+
     <MaxSupportedLangVersion>$(_MaxSupportedLangVersion)</MaxSupportedLangVersion>
     <LangVersion Condition="'$(LangVersion)' == '' AND '$(_MaxSupportedLangVersion)' != ''">$(_MaxSupportedLangVersion)</LangVersion>
   </PropertyGroup>
diff --git a/src/Compilers/Core/MSBuildTask/Microsoft.Managed.Core.targets b/src/Compilers/Core/MSBuildTask/Microsoft.Managed.Core.targets
index 5c035bb1ba9ff..d742060eeeab5 100644
--- a/src/Compilers/Core/MSBuildTask/Microsoft.Managed.Core.targets
+++ b/src/Compilers/Core/MSBuildTask/Microsoft.Managed.Core.targets
@@ -50,10 +50,19 @@
     </PropertyGroup>
   </Target>
 
+  <!--
+    ========================
+    SkipAnalyzers Support
+    ========================
+    
+    -->
+  <UsingTask TaskName="Microsoft.CodeAnalysis.BuildTasks.ShowMessageForImplicitlySkipAnalyzers" AssemblyFile="$(MSBuildThisFileDirectory)Microsoft.Build.Tasks.CodeAnalysis.dll" />
+
   <Target Name="_ComputeSkipAnalyzers" BeforeTargets="CoreCompile">
-    <!-- First, force clear non-user facing property '_SkipAnalyzers'. -->
+    <!-- First, force clear non-user facing properties '_SkipAnalyzers' and '_ImplicitlySkipAnalyzers'. -->
     <PropertyGroup>
       <_SkipAnalyzers></_SkipAnalyzers>
+      <_ImplicitlySkipAnalyzers></_ImplicitlySkipAnalyzers>
     </PropertyGroup>
 
     <!--
@@ -70,6 +79,43 @@
                               ('$(RunAnalyzers)' == '' and '$(RunAnalyzersDuringBuild)' == 'false')">
       <_SkipAnalyzers>true</_SkipAnalyzers>
     </PropertyGroup>
+
+    <!-- PERF: For builds which are indirectly triggered inside Visual Studio from commands 
+               such as from 'Run Tests' or 'Start Debugging', we implicitly skip analyzers to speed up the build.
+               We only do so by default when 'TreatWarningsAsErrors' is not 'true'. For the scenario where
+			         'TreatWarningsAsErrors' is 'true', users can explicitly enable this functionality by setting
+			         'OptimizeImplicitlyTriggeredBuild' to 'true'.
+               NOTE: This feature is currently supported only for SDK-style projects, i.e. UsingMicrosoftNETSdk = true.
+    -->
+    <PropertyGroup Condition="'$(_SkipAnalyzers)' == '' and
+                              '$(IsImplicitlyTriggeredBuild)' == 'true' and
+                              '$(UsingMicrosoftNETSdk)' == 'true' and
+                              ('$(TreatWarningsAsErrors)' != 'true' or '$(OptimizeImplicitlyTriggeredBuild)' == 'true')">
+      <_ImplicitlySkipAnalyzers>true</_ImplicitlySkipAnalyzers>
+      <_SkipAnalyzers>true</_SkipAnalyzers>
+    </PropertyGroup>
+
+    <!-- Display a message to inform the users about us implicitly skipping analyzers for speeding up indirect builds. -->
+    <ShowMessageForImplicitlySkipAnalyzers Condition="'$(_ImplicitlySkipAnalyzers)' == 'true'"/>
+
+    <!-- Semaphore file to indicate the time stamp for last build with skipAnalyzers flag. -->
+    <PropertyGroup>
+      <_LastBuildWithSkipAnalyzers>$(IntermediateOutputPath)$(MSBuildProjectFile).BuildWithSkipAnalyzers</_LastBuildWithSkipAnalyzers>
+    </PropertyGroup>
+
+    <!-- '_LastBuildWithSkipAnalyzers' semaphore file, if exists, is passed as custom additional file input to builds without skipAnalyzers flag to ensure correct incremental builds. 
+	       Additionally, we need to pass this file as an 'UpToDateCheckInput' item with 'Kind = ImplicitBuild' for project system's fast-upto-date check to work correctly.
+		     See https://github.com/dotnet/project-system/issues/7290 for details.
+	  -->
+    <ItemGroup Condition="Exists('$(_LastBuildWithSkipAnalyzers)')">
+      <CustomAdditionalCompileInputs Include="$(_LastBuildWithSkipAnalyzers)" Condition="'$(_SkipAnalyzers)' != 'true'"/>
+      <UpToDateCheckInput Include="$(_LastBuildWithSkipAnalyzers)" Kind="ImplicitBuild"/>
+    </ItemGroup>
+  </Target>
+
+  <!-- We touch and create a semaphore file after build to indicate the time stamp for last build with skipAnalyzers flag. -->
+  <Target Name="_TouchLastBuildWithSkipAnalyzers" Condition="'$(_SkipAnalyzers)' == 'true'" AfterTargets="CoreCompile">
+    <Touch AlwaysCreate="true" Files="$(_LastBuildWithSkipAnalyzers)"/>
   </Target>
 
   <!--
diff --git a/src/Compilers/Core/MSBuildTask/ShowMessageForImplicitlySkipAnalyzers.cs b/src/Compilers/Core/MSBuildTask/ShowMessageForImplicitlySkipAnalyzers.cs
new file mode 100644
index 0000000000000..8ef29eec173b0
--- /dev/null
+++ b/src/Compilers/Core/MSBuildTask/ShowMessageForImplicitlySkipAnalyzers.cs
@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using System.Text;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.BuildTasks
+{
+    /// <summary>
+    /// Logs a localizable message for implicitly skipping analyzers for implicitly triggered builds.
+    /// </summary>
+    public sealed class ShowMessageForImplicitlySkipAnalyzers : Task
+    {
+        public override bool Execute()
+        {
+            Log.LogMessage(MessageImportance.High, ErrorString.ImplicitlySkipAnalyzersMessage);
+            return true;
+        }
+    }
+}
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.cs.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.cs.xlf
index be3cfb89efd41..3550ff332fe11 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.cs.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.cs.xlf
@@ -99,6 +99,11 @@
         <target state="translated">Soubor {0} se nepovedlo přečíst: {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">Sdílená kompilace se nepovedla, použije se znovu nástroj: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.de.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.de.xlf
index d92deb0466159..424d63f5255e2 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.de.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.de.xlf
@@ -99,6 +99,11 @@
         <target state="translated">Die Datei "{0}" konnte nicht gelesen werden: {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">Fehler bei der freigegebenen Kompilierung. Fallback auf folgendes Tool: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.es.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.es.xlf
index e5da65f0a3cd0..2e1b47040521b 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.es.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.es.xlf
@@ -99,6 +99,11 @@
         <target state="translated">No se pudo leer el archivo "{0}": {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">Error de la compilación compartida. Se recurre a la herramienta: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.fr.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.fr.xlf
index 73cbcbd6bf248..c61e911467652 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.fr.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.fr.xlf
@@ -99,6 +99,11 @@
         <target state="translated">Impossible de lire le fichier "{0}" : {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">Échec de la compilation partagée ; retour à l'outil : {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.it.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.it.xlf
index ceded9375d19e..30b349bb169ee 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.it.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.it.xlf
@@ -99,6 +99,11 @@
         <target state="translated">Non è stato possibile leggere il file "{0}": {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">La compilazione condivisa non è riuscita. Verrà eseguito il fallback allo strumento: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ja.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ja.xlf
index f76ab80671805..7c683c1ef141d 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ja.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ja.xlf
@@ -99,6 +99,11 @@
         <target state="translated">ファイル "{0}" を読み取ることができませんでした: {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">共有コンパイルに失敗しました。ツールにフォールバックします: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ko.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ko.xlf
index 92f282b4264aa..6365413555e60 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ko.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ko.xlf
@@ -99,6 +99,11 @@
         <target state="translated">"{0}" 파일을 읽을 수 없습니다. {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">공유 컴파일 실패, 다음 도구로 변경 중: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.pl.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.pl.xlf
index 473b3c7ffa193..8983b419939bb 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.pl.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.pl.xlf
@@ -99,6 +99,11 @@
         <target state="translated">Nie można odczytać pliku „{0}”: {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">Udostępniona kompilacja nie powiodła się; nastąpi powrót do narzędzia: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.pt-BR.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.pt-BR.xlf
index 726fbf466519a..a161ac83e130f 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.pt-BR.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.pt-BR.xlf
@@ -99,6 +99,11 @@
         <target state="translated">Não foi possível ler o arquivo "{0}": {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">Compilação compartilhada com falha; fazendo fallback para a ferramenta: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ru.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ru.xlf
index 71e0fd0f69953..6a17a1bc2e5c3 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ru.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.ru.xlf
@@ -99,6 +99,11 @@
         <target state="translated">Не удалось считать файл "{0}": {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">Сбой общей компиляции; возврат к средству {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.tr.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.tr.xlf
index ca6aac94ded0d..3647587d9f87b 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.tr.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.tr.xlf
@@ -99,6 +99,11 @@
         <target state="translated">"{0}" dosyası okunamadı: {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">Paylaşılan derleme başarısız oldu; önceki araca dönülüyor: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.zh-Hans.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.zh-Hans.xlf
index 7a9e0b113eb87..6d72c6260097f 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.zh-Hans.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.zh-Hans.xlf
@@ -99,6 +99,11 @@
         <target state="translated">无法读取文件 "{0}": {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">共享编译失败; 回到工具: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.zh-Hant.xlf b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.zh-Hant.xlf
index 8c211d4ea1480..d4b81af9a79ea 100644
--- a/src/Compilers/Core/MSBuildTask/xlf/ErrorString.zh-Hant.xlf
+++ b/src/Compilers/Core/MSBuildTask/xlf/ErrorString.zh-Hant.xlf
@@ -99,6 +99,11 @@
         <target state="translated">無法讀取檔案 "{0}": {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="ImplicitlySkipAnalyzersMessage">
+        <source>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</source>
+        <target state="new">Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="SharedCompilationFallback">
         <source>Shared compilation failed; falling back to tool: {0}</source>
         <target state="translated">共用編譯失敗; 將回到工具: {0}</target>
diff --git a/src/Compilers/Core/MSBuildTaskTests/TargetTests.cs b/src/Compilers/Core/MSBuildTaskTests/TargetTests.cs
index 469887809ffb9..8cabe33d65fc8 100644
--- a/src/Compilers/Core/MSBuildTaskTests/TargetTests.cs
+++ b/src/Compilers/Core/MSBuildTaskTests/TargetTests.cs
@@ -20,7 +20,7 @@
 
 namespace Microsoft.CodeAnalysis.BuildTasks.UnitTests
 {
-    public class TargetTests
+    public class TargetTests : TestBase
     {
         [Fact]
         public void GenerateEditorConfigShouldNotRunWhenNoPropertiesOrMetadata()
@@ -399,7 +399,8 @@ public void GenerateEditorConfigCoreHandlesMalformedCompilerVisibleItemMetadata(
         [InlineData(".NETCoreApp", "3.0", "8.0")]
         [InlineData(".NETCoreApp", "3.1", "8.0")]
         [InlineData(".NETCoreApp", "5.0", "9.0")]
-        [InlineData(".NETCoreApp", "6.0", "")]
+        [InlineData(".NETCoreApp", "6.0", "10.0")]
+        [InlineData(".NETCoreApp", "7.0", "")]
 
         [InlineData(".NETStandard", "1.0", "7.3")]
         [InlineData(".NETStandard", "1.5", "7.3")]
@@ -408,6 +409,7 @@ public void GenerateEditorConfigCoreHandlesMalformedCompilerVisibleItemMetadata(
 
         [InlineData("UnknownTFM", "0.0", "7.3")]
         [InlineData("UnknownTFM", "5.0", "7.3")]
+        [InlineData("UnknownTFM", "6.0", "7.3")]
         public void LanguageVersionGivenTargetFramework(string tfi, string tfv, string expectedVersion)
         {
             XmlReader xmlReader = XmlReader.Create(new StringReader($@"
@@ -432,7 +434,7 @@ public void LanguageVersionGivenTargetFramework(string tfi, string tfv, string e
             // This will fail whenever the current language version is updated.
             // Ensure you update the target files to select the correct CSharp version for the newest target framework
             // and add to the theory data above to cover it, before changing this version to make the test pass again.
-            Assert.Equal(CSharp.LanguageVersion.CSharp9, CSharp.LanguageVersionFacts.CurrentVersion);
+            Assert.Equal(CSharp.LanguageVersion.CSharp10, CSharp.LanguageVersionFacts.CurrentVersion);
         }
 
         [Fact]
@@ -714,6 +716,144 @@ static string getPropertyGroup(string propertyName, bool? propertyValue)
             }
         }
 
+        [Theory, CombinatorialData]
+        [WorkItem(1337109, "https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1337109")]
+        public void TestImplicitlySkipAnalyzers(
+            [CombinatorialValues(true, false, null)] bool? runAnalyzers,
+            [CombinatorialValues(true, false, null)] bool? implicitBuild,
+            [CombinatorialValues(true, false, null)] bool? treatWarningsAsErrors,
+            [CombinatorialValues(true, false, null)] bool? optimizeImplicitBuild,
+            [CombinatorialValues(true, null)] bool? sdkStyleProject)
+        {
+            var runAnalyzersPropertyGroupString = getPropertyGroup("RunAnalyzers", runAnalyzers);
+            var implicitBuildPropertyGroupString = getPropertyGroup("IsImplicitlyTriggeredBuild", implicitBuild);
+            var treatWarningsAsErrorsPropertyGroupString = getPropertyGroup("TreatWarningsAsErrors", treatWarningsAsErrors);
+            var optimizeImplicitBuildPropertyGroupString = getPropertyGroup("OptimizeImplicitlyTriggeredBuild", optimizeImplicitBuild);
+            var sdkStyleProjectPropertyGroupString = getPropertyGroup("UsingMicrosoftNETSdk", sdkStyleProject);
+
+            XmlReader xmlReader = XmlReader.Create(new StringReader($@"
+<Project>
+    <Import Project=""Microsoft.Managed.Core.targets"" />
+
+{runAnalyzersPropertyGroupString}
+{implicitBuildPropertyGroupString}
+{treatWarningsAsErrorsPropertyGroupString}
+{optimizeImplicitBuildPropertyGroupString}
+{sdkStyleProjectPropertyGroupString}
+
+
+</Project>
+"));
+
+            var instance = CreateProjectInstance(xmlReader);
+
+            bool runSuccess = instance.Build(target: "_ComputeSkipAnalyzers", GetTestLoggers());
+            Assert.True(runSuccess);
+
+            var analyzersEnabled = runAnalyzers ?? true;
+            var expectedImplicitlySkippedAnalyzers = analyzersEnabled &&
+                implicitBuild == true &&
+                sdkStyleProject == true &&
+                (treatWarningsAsErrors != true || optimizeImplicitBuild == true);
+            var expectedImplicitlySkippedAnalyzersValue = expectedImplicitlySkippedAnalyzers ? "true" : "";
+            var actualImplicitlySkippedAnalyzersValue = instance.GetPropertyValue("_ImplicitlySkipAnalyzers");
+            Assert.Equal(expectedImplicitlySkippedAnalyzersValue, actualImplicitlySkippedAnalyzersValue);
+
+            var expectedSkipAnalyzersValue = !analyzersEnabled || expectedImplicitlySkippedAnalyzers ? "true" : "";
+            var actualSkipAnalyzersValue = instance.GetPropertyValue("_SkipAnalyzers");
+            Assert.Equal(expectedSkipAnalyzersValue, actualSkipAnalyzersValue);
+            return;
+
+            static string getPropertyGroup(string propertyName, bool? propertyValue)
+            {
+                if (!propertyValue.HasValue)
+                {
+                    return string.Empty;
+                }
+
+                return $@"
+    <PropertyGroup>
+        <{propertyName}>{propertyValue.Value}</{propertyName}>
+    </PropertyGroup>";
+            }
+        }
+
+        [Theory, CombinatorialData]
+        [WorkItem(1337109, "https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1337109")]
+        public void TestLastBuildWithSkipAnalyzers(
+            [CombinatorialValues(true, false, null)] bool? runAnalyzers,
+            bool lastBuildWithSkipAnalyzersFileExists)
+        {
+            var runAnalyzersPropertyGroupString = getPropertyGroup("RunAnalyzers", runAnalyzers);
+            var intermediatePathDir = Temp.CreateDirectory();
+            var intermediatePath = intermediatePathDir + Path.DirectorySeparatorChar.ToString();
+
+            XmlReader xmlReader = XmlReader.Create(new StringReader($@"
+<Project>
+    <Import Project=""Microsoft.Managed.Core.targets"" />
+
+{runAnalyzersPropertyGroupString}
+
+    <PropertyGroup>
+        <IntermediateOutputPath>{intermediatePath}</IntermediateOutputPath>
+    </PropertyGroup>
+
+</Project>
+"));
+
+            var instance = CreateProjectInstance(xmlReader);
+
+            var msbuildProjectFileName = instance.GetPropertyValue("MSBuildProjectFile");
+            var expectedLastBuildWithSkipAnalyzers = intermediatePath + msbuildProjectFileName + ".BuildWithSkipAnalyzers";
+            if (lastBuildWithSkipAnalyzersFileExists)
+            {
+                _ = intermediatePathDir.CreateFile(msbuildProjectFileName + ".BuildWithSkipAnalyzers");
+            }
+
+            bool runSuccess = instance.Build(target: "_ComputeSkipAnalyzers", GetTestLoggers());
+            Assert.True(runSuccess);
+
+            var actualLastBuildWithSkipAnalyzers = instance.GetPropertyValue("_LastBuildWithSkipAnalyzers");
+            Assert.Equal(expectedLastBuildWithSkipAnalyzers, actualLastBuildWithSkipAnalyzers);
+
+            var skipAnalyzers = !(runAnalyzers ?? true);
+            var expectedCustomAdditionalCompileInput = lastBuildWithSkipAnalyzersFileExists && !skipAnalyzers;
+
+            var items = instance.GetItems("CustomAdditionalCompileInputs");
+            var expectedItemCount = expectedCustomAdditionalCompileInput ? 1 : 0;
+            Assert.Equal(expectedItemCount, items.Count);
+            if (expectedCustomAdditionalCompileInput)
+            {
+                Assert.Equal(expectedLastBuildWithSkipAnalyzers, items.Single().EvaluatedInclude);
+            }
+
+            var expectedUpToDateCheckInput = lastBuildWithSkipAnalyzersFileExists;
+            items = instance.GetItems("UpToDateCheckInput");
+            expectedItemCount = expectedUpToDateCheckInput ? 1 : 0;
+            Assert.Equal(expectedItemCount, items.Count);
+            if (expectedUpToDateCheckInput)
+            {
+                var item = items.Single();
+                Assert.Equal(expectedLastBuildWithSkipAnalyzers, item.EvaluatedInclude);
+                Assert.Equal("ImplicitBuild", item.GetMetadataValue("Kind"));
+            }
+
+            return;
+
+            static string getPropertyGroup(string propertyName, bool? propertyValue)
+            {
+                if (!propertyValue.HasValue)
+                {
+                    return string.Empty;
+                }
+
+                return $@"
+    <PropertyGroup>
+        <{propertyName}>{propertyValue.Value}</{propertyName}>
+    </PropertyGroup>";
+            }
+        }
+
         [Fact]
         public void ProjectCapabilityIsNotAddedWhenRoslynComponentIsUnspecified()
         {
@@ -769,6 +909,13 @@ private static ProjectInstance CreateProjectInstance(XmlReader reader)
                 { "Directories", "System.String[]" }
             });
 
+            // dummy Message task
+            addTask(proj, "Message", new()
+            {
+                { "Text", "System.String" },
+                { "Importance", "System.String" }
+            });
+
             // create an instance and return it
             return proj.CreateProjectInstance();
 
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.resx b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
index 0a2a7e6e0271f..c1281b0f0fcab 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.resx
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
@@ -698,15 +698,16 @@
     <value>Multiple global analyzer config files set the same key. It has been unset.</value>
   </data>
   <data name="HintNameUniquePerGenerator" xml:space="preserve">
-    <value>The hintName of the added source file must be unique within a generator.</value>
+    <value>The hintName '{0}' of the added source file must be unique within a generator.</value>
+    <comment>{0}: the provided hintname</comment>
   </data>
   <data name="HintNameInvalidChar" xml:space="preserve">
-    <value>The hintName contains an invalid character '{0}' at position {1}.</value>
-    <comment>{0}: the invalid character, {1} the position it occurred at</comment>
+    <value>The hintName '{0}' contains an invalid character '{1}' at position {2}.</value>
+    <comment>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</comment>
   </data>
   <data name="SourceTextRequiresEncoding" xml:space="preserve">
-    <value>The provided SourceText must have an explicit encoding set.</value>
-    <comment>'SourceText' is not localizable.</comment>
+    <value>The SourceText with hintName '{0}' must have an explicit encoding set.</value>
+    <comment>'SourceText' is not localizable. {0}: the provided hintname</comment>
   </data>
   <data name="AssemblyReferencesNetFramework" xml:space="preserve">
     <value>The assembly containing type '{0}' references .NET Framework, which is not supported.</value>
diff --git a/src/Compilers/Core/Portable/Collections/ImmutableArrayExtensions.cs b/src/Compilers/Core/Portable/Collections/ImmutableArrayExtensions.cs
index d6995bf657fa3..b2f8948f09f10 100644
--- a/src/Compilers/Core/Portable/Collections/ImmutableArrayExtensions.cs
+++ b/src/Compilers/Core/Portable/Collections/ImmutableArrayExtensions.cs
@@ -677,6 +677,17 @@ internal static ImmutableArray<T> Concat<T>(this ImmutableArray<T> first, Immuta
             return builder.ToImmutableAndFree();
         }
 
+        internal static ImmutableArray<T> Concat<T>(this ImmutableArray<T> first, ImmutableArray<T> second, ImmutableArray<T> third, ImmutableArray<T> fourth, ImmutableArray<T> fifth)
+        {
+            var builder = ArrayBuilder<T>.GetInstance(first.Length + second.Length + third.Length + fourth.Length + fifth.Length);
+            builder.AddRange(first);
+            builder.AddRange(second);
+            builder.AddRange(third);
+            builder.AddRange(fourth);
+            builder.AddRange(fifth);
+            return builder.ToImmutableAndFree();
+        }
+
         internal static ImmutableArray<T> Concat<T>(this ImmutableArray<T> first, T second)
         {
             return first.Add(second);
diff --git a/src/Compilers/Core/Portable/Collections/ImmutableSegmentedDictionaryBuilderExtensions.cs b/src/Compilers/Core/Portable/Collections/ImmutableSegmentedDictionaryBuilderExtensions.cs
new file mode 100644
index 0000000000000..5b8ee123d6156
--- /dev/null
+++ b/src/Compilers/Core/Portable/Collections/ImmutableSegmentedDictionaryBuilderExtensions.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Collections
+{
+    internal static class ImmutableSegmentedDictionaryBuilderExtensions
+    {
+        public static bool TryAdd<T>(
+            this ImmutableSegmentedDictionary<T, VoidResult>.Builder dictionary,
+            T value)
+            where T : notnull
+        {
+#if NETCOREAPP
+            return dictionary.TryAdd(value, default);
+#else
+            if (dictionary.ContainsKey(value))
+                return false;
+
+            dictionary[value] = default;
+            return true;
+#endif
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerFileReference.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerFileReference.cs
index 55588e6f78a21..46a672fe5d9c3 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerFileReference.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerFileReference.cs
@@ -57,7 +57,7 @@ public AnalyzerFileReference(string fullPath, IAnalyzerAssemblyLoader assemblyLo
             _assemblyLoader = assemblyLoader ?? throw new ArgumentNullException(nameof(assemblyLoader));
 
             _diagnosticAnalyzers = new(this, typeof(DiagnosticAnalyzerAttribute), GetDiagnosticsAnalyzerSupportedLanguages, allowNetFramework: true);
-            _generators = new(this, typeof(GeneratorAttribute), GetGeneratorSupportedLanguages, allowNetFramework: false);
+            _generators = new(this, typeof(GeneratorAttribute), GetGeneratorSupportedLanguages, allowNetFramework: false, coerceFunction: CoerceGeneratorType);
 
             // Note this analyzer full path as a dependency location, so that the analyzer loader
             // can correctly load analyzer dependencies.
@@ -322,8 +322,18 @@ private static IEnumerable<string> ReadLanguagesFromAttribute(ref BlobReader arg
             }
             return SpecializedCollections.EmptyEnumerable<string>();
         }
+
 #nullable enable
 
+        private static ISourceGenerator? CoerceGeneratorType(object? generator)
+        {
+            if (generator is IIncrementalGenerator incrementalGenerator)
+            {
+                return new IncrementalGeneratorWrapper(incrementalGenerator);
+            }
+            return null;
+        }
+
         private static string GetFullyQualifiedTypeName(TypeDefinition typeDef, PEModule peModule)
         {
             var declaringType = typeDef.GetDeclaringType();
@@ -347,16 +357,18 @@ private sealed class Extensions<TExtension>
             private readonly Type _attributeType;
             private readonly AttributeLanguagesFunc _languagesFunc;
             private readonly bool _allowNetFramework;
+            private readonly Func<object?, TExtension?>? _coerceFunction;
             private ImmutableArray<TExtension> _lazyAllExtensions;
             private ImmutableDictionary<string, ImmutableArray<TExtension>> _lazyExtensionsPerLanguage;
             private ImmutableSortedDictionary<string, ImmutableSortedSet<string>>? _lazyExtensionTypeNameMap;
 
-            internal Extensions(AnalyzerFileReference reference, Type attributeType, AttributeLanguagesFunc languagesFunc, bool allowNetFramework)
+            internal Extensions(AnalyzerFileReference reference, Type attributeType, AttributeLanguagesFunc languagesFunc, bool allowNetFramework, Func<object?, TExtension?>? coerceFunction = null)
             {
                 _reference = reference;
                 _attributeType = attributeType;
                 _languagesFunc = languagesFunc;
                 _allowNetFramework = allowNetFramework;
+                _coerceFunction = coerceFunction;
                 _lazyAllExtensions = default;
                 _lazyExtensionsPerLanguage = ImmutableDictionary<string, ImmutableArray<TExtension>>.Empty;
             }
@@ -566,10 +578,10 @@ private ImmutableArray<TExtension> GetAnalyzersForTypeNames(Assembly analyzerAss
                         }
                     }
 
-                    TExtension? analyzer;
+                    object? typeInstance;
                     try
                     {
-                        analyzer = Activator.CreateInstance(type) as TExtension;
+                        typeInstance = Activator.CreateInstance(type);
                     }
                     catch (Exception e)
                     {
@@ -578,6 +590,7 @@ private ImmutableArray<TExtension> GetAnalyzersForTypeNames(Assembly analyzerAss
                         continue;
                     }
 
+                    TExtension? analyzer = typeInstance as TExtension ?? _coerceFunction?.Invoke(typeInstance);
                     if (analyzer != null)
                     {
                         analyzers.Add(analyzer);
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerReference.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerReference.cs
index ef0c4750888bb..664086460e861 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerReference.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerReference.cs
@@ -70,7 +70,7 @@ public virtual string Display
         public virtual ImmutableArray<ISourceGenerator> GetGenerators() => ImmutableArray<ISourceGenerator>.Empty;
 
         /// <summary>
-        /// Gets all the diagnostic generators defined in this assembly reference for the given <paramref name="language"/>.
+        /// Gets all the generators defined in this assembly reference for the given <paramref name="language"/>.
         /// </summary>
         /// <param name="language">Language name.</param>
         public virtual ImmutableArray<ISourceGenerator> GetGenerators(string language) => ImmutableArray<ISourceGenerator>.Empty;
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
index 353c61b7f2e88..46b3955fa274d 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
@@ -38,6 +38,18 @@ internal sealed class DeltaMetadataWriter : MetadataWriter
         private readonly EventOrPropertyMapIndex _propertyMap;
         private readonly MethodImplIndex _methodImpls;
 
+        // For the EncLog table we need to know which things we're emitting custom attributes for so we can
+        // correctly map the attributes to row numbers of existing attributes for that target
+        private readonly Dictionary<EntityHandle, int> _customAttributeParentCounts;
+
+        // For the EncMap table we need to keep a list of exactly which rows in the CustomAttributes table are updated
+        // since we spread these out amongst existing rows, it's not just a contiguous set
+        private readonly List<int> _customAttributeEncMapRows;
+
+        // Keep track of which CustomAttributes rows are added in this and previous deltas, over what is in the
+        // original metadata
+        private readonly Dictionary<EntityHandle, ImmutableArray<int>> _customAttributesAdded;
+
         private readonly HeapOrReferenceIndex<AssemblyIdentity> _assemblyRefIndex;
         private readonly HeapOrReferenceIndex<string> _moduleRefIndex;
         private readonly InstanceAndStructuralReferenceIndex<ITypeMemberReference> _memberRefIndex;
@@ -90,6 +102,10 @@ public DeltaMetadataWriter(
             _propertyMap = new EventOrPropertyMapIndex(this.TryGetExistingPropertyMapIndex, sizes[(int)TableIndex.PropertyMap]);
             _methodImpls = new MethodImplIndex(this, sizes[(int)TableIndex.MethodImpl]);
 
+            _customAttributeParentCounts = new Dictionary<EntityHandle, int>();
+            _customAttributeEncMapRows = new List<int>();
+            _customAttributesAdded = new Dictionary<EntityHandle, ImmutableArray<int>>();
+
             _assemblyRefIndex = new HeapOrReferenceIndex<AssemblyIdentity>(this, lastRowId: sizes[(int)TableIndex.AssemblyRef]);
             _moduleRefIndex = new HeapOrReferenceIndex<string>(this, lastRowId: sizes[(int)TableIndex.ModuleRef]);
             _memberRefIndex = new InstanceAndStructuralReferenceIndex<ITypeMemberReference>(this, new MemberRefComparer(this), lastRowId: sizes[(int)TableIndex.MemberRef]);
@@ -171,6 +187,7 @@ internal EmitBaseline GetDelta(EmitBaseline baseline, Compilation compilation, G
                 eventMapAdded: AddRange(_previousGeneration.EventMapAdded, _eventMap.GetAdded()),
                 propertyMapAdded: AddRange(_previousGeneration.PropertyMapAdded, _propertyMap.GetAdded()),
                 methodImplsAdded: AddRange(_previousGeneration.MethodImplsAdded, _methodImpls.GetAdded()),
+                customAttributesAdded: AddRange(_previousGeneration.CustomAttributesAdded, _customAttributesAdded, replace: true),
                 tableEntriesAdded: ImmutableArray.Create(tableSizes),
                 // Blob stream is concatenated aligned.
                 blobStreamLengthAdded: metadataSizes.GetAlignedHeapSize(HeapIndex.Blob) + _previousGeneration.BlobStreamLengthAdded,
@@ -692,6 +709,17 @@ private EncLocalInfo CreateEncLocalInfo(ILocalDefinition localDef, byte[] signat
             return new EncLocalInfo(localDef.SlotInfo, translatedType, localDef.Constraints, signature);
         }
 
+        protected override int AddCustomAttributesToTable(EntityHandle parentHandle, IEnumerable<ICustomAttribute> attributes)
+        {
+            // The base class will write out the actual metadata for us
+            var numAttributesEmitted = base.AddCustomAttributesToTable(parentHandle, attributes);
+
+            // We need to keep track of all of the things attributes could be associated with in this delta, in order to populate the EncLog and Map tables
+            _customAttributeParentCounts.Add(parentHandle, numAttributesEmitted);
+
+            return numAttributesEmitted;
+        }
+
         protected override void PopulateEncLogTableRows(ImmutableArray<int> rowCounts)
         {
             // The EncLog table is a log of all the operations needed
@@ -720,7 +748,7 @@ protected override void PopulateEncLogTableRows(ImmutableArray<int> rowCounts)
             PopulateEncLogTableParameters();
 
             PopulateEncLogTableRows(TableIndex.Constant, previousSizes, deltaSizes);
-            PopulateEncLogTableRows(TableIndex.CustomAttribute, previousSizes, deltaSizes);
+            PopulateEncLogTableCustomAttributes();
             PopulateEncLogTableRows(TableIndex.DeclSecurity, previousSizes, deltaSizes);
             PopulateEncLogTableRows(TableIndex.ClassLayout, previousSizes, deltaSizes);
             PopulateEncLogTableRows(TableIndex.FieldLayout, previousSizes, deltaSizes);
@@ -802,6 +830,118 @@ private void PopulateEncLogTableParameters()
             }
         }
 
+        /// <summary>
+        /// CustomAttributes point to their target via the Parent column so we cannot simply output new rows
+        /// in the delta or we would end up with duplicates, but we also don't want to do complex logic to determine
+        /// which attributes have changes, so we just emit them all.
+        /// This means our logic for emitting CustomAttributes is to update any existing rows, either from the original
+        /// compilation or subsequent deltas, and only add more if we need to. The EncLog table is the thing that tells
+        /// the runtime which row a CustomAttributes row is (ie, new or existing)
+        /// </summary>
+        private void PopulateEncLogTableCustomAttributes()
+        {
+            // List of attributes that need to be emitted to delete a previously emitted attribute
+            var deletedAttributeRows = new List<(int parentRowId, HandleKind kind)>();
+            var customAttributesAdded = new Dictionary<EntityHandle, ArrayBuilder<int>>();
+
+            // The data in _previousGeneration.CustomAttributesAdded is not nicely sorted, or even necessarily contiguous
+            // so we need to map each target onto the rows its attributes occupy so we know which rows to update
+            var lastRowId = _previousGeneration.OriginalMetadata.MetadataReader.GetTableRowCount(TableIndex.CustomAttribute);
+            if (_previousGeneration.CustomAttributesAdded.Count > 0)
+            {
+                lastRowId = _previousGeneration.CustomAttributesAdded.SelectMany(s => s.Value).Max();
+            }
+
+            // Iterate through the parents we emitted custom attributes for, in parent order
+            foreach (var (parent, count) in _customAttributeParentCounts.OrderBy(kvp => CodedIndex.HasCustomAttribute(kvp.Key)))
+            {
+                int index = 0;
+
+                // First we try to update any existing attributes.
+                // GetCustomAttributes does a binary search, so is fast. We presume that the number of rows in the original metadata
+                // greatly outnumbers the amount of parents emitted in this delta so even with repeated searches this is still
+                // quicker than iterating the entire original table, even once.
+                var existingCustomAttributes = _previousGeneration.OriginalMetadata.MetadataReader.GetCustomAttributes(parent);
+                foreach (var attributeHandle in existingCustomAttributes)
+                {
+                    int rowId = MetadataTokens.GetRowNumber(attributeHandle);
+                    AddLogEntryOrDelete(rowId, parent, add: index < count);
+                    index++;
+                }
+
+                // If we emitted any attributes for this parent in previous deltas then we either need to update
+                // them next, or delete them if necessary
+                if (_previousGeneration.CustomAttributesAdded.TryGetValue(parent, out var rowIds))
+                {
+                    foreach (var rowId in rowIds)
+                    {
+                        TrackCustomAttributeAdded(rowId, parent);
+                        AddLogEntryOrDelete(rowId, parent, add: index < count);
+                        index++;
+                    }
+                }
+
+                // Finally if there are still attributes for this parent left, they are additions new to this delta
+                for (int i = index; i < count; i++)
+                {
+                    lastRowId++;
+                    TrackCustomAttributeAdded(lastRowId, parent);
+                    AddEncLogEntry(lastRowId);
+                }
+            }
+
+            // Save the attributes we've emitted, and the ones from previous deltas, for use in the next generation
+            foreach (var (parent, rowIds) in customAttributesAdded)
+            {
+                _customAttributesAdded.Add(parent, rowIds.ToImmutableAndFree());
+            }
+
+            // Add attributes and log entries for everything we've deleted
+            foreach (var row in deletedAttributeRows)
+            {
+                // now emit a "delete" row with a parent that is for the 0 row of the same table as the existing one
+                if (!MetadataTokens.TryGetTableIndex(row.kind, out var tableIndex))
+                {
+                    throw new InvalidOperationException("Trying to delete a custom attribute for a parent kind that doesn't have a matching table index.");
+                }
+                metadata.AddCustomAttribute(MetadataTokens.Handle(tableIndex, 0), MetadataTokens.EntityHandle(TableIndex.MemberRef, 0), value: default);
+
+                AddEncLogEntry(row.parentRowId);
+            }
+
+            void AddEncLogEntry(int rowId)
+            {
+                _customAttributeEncMapRows.Add(rowId);
+                metadata.AddEncLogEntry(
+                    entity: MetadataTokens.CustomAttributeHandle(rowId),
+                    code: EditAndContinueOperation.Default);
+            }
+
+            void AddLogEntryOrDelete(int rowId, EntityHandle parent, bool add)
+            {
+                if (add)
+                {
+                    // Update this row
+                    AddEncLogEntry(rowId);
+                }
+                else
+                {
+                    // Delete this row
+                    deletedAttributeRows.Add((rowId, parent.Kind));
+                }
+            }
+
+            void TrackCustomAttributeAdded(int nextRowId, EntityHandle parent)
+            {
+                if (!customAttributesAdded.TryGetValue(parent, out var existing))
+                {
+                    existing = ArrayBuilder<int>.GetInstance();
+                    customAttributesAdded.Add(parent, existing);
+                }
+                existing.Add(nextRowId);
+            }
+        }
+
         private void PopulateEncLogTableRows<T>(DefinitionIndex<T> index, TableIndex tableIndex)
             where T : class, IDefinition
         {
@@ -854,7 +994,7 @@ protected override void PopulateEncMapTableRows(ImmutableArray<int> rowCounts)
 
             AddReferencedTokens(tokens, TableIndex.Param, previousSizes, deltaSizes);
             AddReferencedTokens(tokens, TableIndex.Constant, previousSizes, deltaSizes);
-            AddReferencedTokens(tokens, TableIndex.CustomAttribute, previousSizes, deltaSizes);
+            AddRowNumberTokens(tokens, _customAttributeEncMapRows, TableIndex.CustomAttribute);
             AddReferencedTokens(tokens, TableIndex.DeclSecurity, previousSizes, deltaSizes);
             AddReferencedTokens(tokens, TableIndex.ClassLayout, previousSizes, deltaSizes);
             AddReferencedTokens(tokens, TableIndex.FieldLayout, previousSizes, deltaSizes);
@@ -981,6 +1121,14 @@ private static void AddDefinitionTokens<T>(ArrayBuilder<EntityHandle> tokens, De
             }
         }
 
+        private static void AddRowNumberTokens(ArrayBuilder<EntityHandle> tokens, IEnumerable<int> rowNumbers, TableIndex tableIndex)
+        {
+            foreach (var row in rowNumbers)
+            {
+                tokens.Add(MetadataTokens.Handle(tableIndex, row));
+            }
+        }
+
         protected override void PopulateEventMapTableRows()
         {
             foreach (var typeId in _eventMap.GetRows())
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs
index b5e2eec851b7e..b16628e10f05b 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs
@@ -212,6 +212,7 @@ public static EmitBaseline CreateInitialBaseline(
                 eventMapAdded: new Dictionary<int, int>(),
                 propertyMapAdded: new Dictionary<int, int>(),
                 methodImplsAdded: new Dictionary<MethodImplKey, int>(),
+                customAttributesAdded: new Dictionary<EntityHandle, ImmutableArray<int>>(),
                 tableEntriesAdded: s_emptyTableSizes,
                 blobStreamLengthAdded: 0,
                 stringStreamLengthAdded: 0,
@@ -262,6 +263,7 @@ public static EmitBaseline CreateInitialBaseline(
         internal readonly IReadOnlyDictionary<int, int> EventMapAdded;
         internal readonly IReadOnlyDictionary<int, int> PropertyMapAdded;
         internal readonly IReadOnlyDictionary<MethodImplKey, int> MethodImplsAdded;
+        internal readonly IReadOnlyDictionary<EntityHandle, ImmutableArray<int>> CustomAttributesAdded;
 
         internal readonly ImmutableArray<int> TableEntriesAdded;
 
@@ -317,6 +319,7 @@ private EmitBaseline(
             IReadOnlyDictionary<int, int> eventMapAdded,
             IReadOnlyDictionary<int, int> propertyMapAdded,
             IReadOnlyDictionary<MethodImplKey, int> methodImplsAdded,
+            IReadOnlyDictionary<EntityHandle, ImmutableArray<int>> customAttributesAdded,
             ImmutableArray<int> tableEntriesAdded,
             int blobStreamLengthAdded,
             int stringStreamLengthAdded,
@@ -377,6 +380,7 @@ private EmitBaseline(
             EventMapAdded = eventMapAdded;
             PropertyMapAdded = propertyMapAdded;
             MethodImplsAdded = methodImplsAdded;
+            CustomAttributesAdded = customAttributesAdded;
             TableEntriesAdded = tableEntriesAdded;
             BlobStreamLengthAdded = blobStreamLengthAdded;
             StringStreamLengthAdded = stringStreamLengthAdded;
@@ -407,6 +411,7 @@ internal EmitBaseline With(
             IReadOnlyDictionary<int, int> eventMapAdded,
             IReadOnlyDictionary<int, int> propertyMapAdded,
             IReadOnlyDictionary<MethodImplKey, int> methodImplsAdded,
+            IReadOnlyDictionary<EntityHandle, ImmutableArray<int>> customAttributesAdded,
             ImmutableArray<int> tableEntriesAdded,
             int blobStreamLengthAdded,
             int stringStreamLengthAdded,
@@ -438,6 +443,7 @@ internal EmitBaseline With(
                 eventMapAdded,
                 propertyMapAdded,
                 methodImplsAdded,
+                customAttributesAdded,
                 tableEntriesAdded,
                 blobStreamLengthAdded: blobStreamLengthAdded,
                 stringStreamLengthAdded: stringStreamLengthAdded,
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs
index c30390aee8bc9..890c0699ec78d 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs
@@ -51,6 +51,7 @@ public EmitBaseline MapBaselineToCompilation(
                 eventMapAdded: baseline.EventMapAdded,
                 propertyMapAdded: baseline.PropertyMapAdded,
                 methodImplsAdded: baseline.MethodImplsAdded,
+                customAttributesAdded: baseline.CustomAttributesAdded,
                 tableEntriesAdded: baseline.TableEntriesAdded,
                 blobStreamLengthAdded: baseline.BlobStreamLengthAdded,
                 stringStreamLengthAdded: baseline.StringStreamLengthAdded,
diff --git a/src/Compilers/Core/Portable/InternalUtilities/IsExternalInit.cs b/src/Compilers/Core/Portable/InternalUtilities/IsExternalInit.cs
index 19138060ce89d..7d1e003609644 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/IsExternalInit.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/IsExternalInit.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/VoidResult.cs b/src/Compilers/Core/Portable/InternalUtilities/VoidResult.cs
similarity index 51%
rename from src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/VoidResult.cs
rename to src/Compilers/Core/Portable/InternalUtilities/VoidResult.cs
index 58b1a49a3ad9a..ea481f9017836 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/VoidResult.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/VoidResult.cs
@@ -2,10 +2,22 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
+
 namespace Roslyn.Utilities
 {
     /// <summary>
     /// Explicitly indicates result is void
     /// </summary>
-    internal struct VoidResult { }
+    internal readonly struct VoidResult : IEquatable<VoidResult>
+    {
+        public override bool Equals(object? obj)
+            => obj is VoidResult;
+
+        public override int GetHashCode()
+            => 0;
+
+        public bool Equals(VoidResult other)
+            => true;
+    }
 }
diff --git a/src/Compilers/Core/Portable/MetadataReader/ModuleExtensions.cs b/src/Compilers/Core/Portable/MetadataReader/ModuleExtensions.cs
index ed245a450a224..1e72ed326be3e 100644
--- a/src/Compilers/Core/Portable/MetadataReader/ModuleExtensions.cs
+++ b/src/Compilers/Core/Portable/MetadataReader/ModuleExtensions.cs
@@ -78,7 +78,7 @@ public static bool ShouldImportField(FieldAttributes flags, MetadataImportOption
         /// explicit interface implementations. For other methods, visibility and the value of
         /// <paramref name="importOptions"/> are considered.
         /// </summary>
-        public static bool ShouldImportMethod(this PEModule module, MethodDefinitionHandle methodDef, MetadataImportOptions importOptions)
+        public static bool ShouldImportMethod(this PEModule module, TypeDefinitionHandle typeDef, MethodDefinitionHandle methodDef, MetadataImportOptions importOptions)
         {
             try
             {
@@ -87,27 +87,11 @@ public static bool ShouldImportMethod(this PEModule module, MethodDefinitionHand
                 // If the method is virtual, it must be accessible, although
                 // it may be an explicit (private) interface implementation.
                 // Otherwise, we need to check the accessibility.
-                if ((flags & MethodAttributes.Virtual) == 0)
+                if ((flags & MethodAttributes.Virtual) == 0 && !acceptBasedOnAccessibility(importOptions, flags) &&
+                    ((flags & MethodAttributes.Static) == 0 || !isMethodImpl(typeDef, methodDef)))
                 {
-                    switch (flags & MethodAttributes.MemberAccessMask)
-                    {
-                        case MethodAttributes.Private:
-                        case MethodAttributes.PrivateScope:
-                            if (importOptions != MetadataImportOptions.All)
-                            {
-                                return false;
-                            }
-
-                            break;
-
-                        case MethodAttributes.Assembly:
-                            if (importOptions == MetadataImportOptions.Public)
-                            {
-                                return false;
-                            }
-
-                            break;
-                    }
+
+                    return false;
                 }
             }
             catch (BadImageFormatException)
@@ -127,6 +111,45 @@ public static bool ShouldImportMethod(this PEModule module, MethodDefinitionHand
             {
                 return true;
             }
+
+            static bool acceptBasedOnAccessibility(MetadataImportOptions importOptions, MethodAttributes flags)
+            {
+                switch (flags & MethodAttributes.MemberAccessMask)
+                {
+                    case MethodAttributes.Private:
+                    case MethodAttributes.PrivateScope:
+                        if (importOptions != MetadataImportOptions.All)
+                        {
+                            return false;
+                        }
+
+                        break;
+
+                    case MethodAttributes.Assembly:
+                        if (importOptions == MetadataImportOptions.Public)
+                        {
+                            return false;
+                        }
+
+                        break;
+                }
+
+                return true;
+            }
+
+            bool isMethodImpl(TypeDefinitionHandle typeDef, MethodDefinitionHandle methodDef)
+            {
+                foreach (var methodImpl in module.GetMethodImplementationsOrThrow(typeDef))
+                {
+                    module.GetMethodImplPropsOrThrow(methodImpl, out EntityHandle body, out _);
+                    if (body == methodDef)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
         }
 
         /// <summary>
diff --git a/src/Compilers/Core/Portable/Operations/ControlFlowGraphBuilder.ConditionalAccessOperationTracker.cs b/src/Compilers/Core/Portable/Operations/ControlFlowGraphBuilder.ConditionalAccessOperationTracker.cs
index d51ad4e5303cf..f3f77c8bfdb6c 100644
--- a/src/Compilers/Core/Portable/Operations/ControlFlowGraphBuilder.ConditionalAccessOperationTracker.cs
+++ b/src/Compilers/Core/Portable/Operations/ControlFlowGraphBuilder.ConditionalAccessOperationTracker.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Compilers/Core/Portable/Operations/Operation.Enumerable.cs b/src/Compilers/Core/Portable/Operations/Operation.Enumerable.cs
index 84e466976926e..a0e1ef8b253dd 100644
--- a/src/Compilers/Core/Portable/Operations/Operation.Enumerable.cs
+++ b/src/Compilers/Core/Portable/Operations/Operation.Enumerable.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Compilers/Core/Portable/Operations/OperationMapBuilder.cs b/src/Compilers/Core/Portable/Operations/OperationMapBuilder.cs
index e3beda6e9cfb3..7a31dcb0fcc12 100644
--- a/src/Compilers/Core/Portable/Operations/OperationMapBuilder.cs
+++ b/src/Compilers/Core/Portable/Operations/OperationMapBuilder.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Compilers/Core/Portable/PEWriter/Members.cs b/src/Compilers/Core/Portable/PEWriter/Members.cs
index 70382dde13c75..fcb78a61af057 100644
--- a/src/Compilers/Core/Portable/PEWriter/Members.cs
+++ b/src/Compilers/Core/Portable/PEWriter/Members.cs
@@ -992,15 +992,36 @@ public static bool ShouldInclude(this ITypeDefinitionMember member, EmitContext
                 return true;
             }
 
+            bool acceptBasedOnVisibility = true;
+
             switch (member.Visibility)
             {
                 case TypeMemberVisibility.Private:
-                    return context.IncludePrivateMembers;
+                    acceptBasedOnVisibility = context.IncludePrivateMembers;
+                    break;
                 case TypeMemberVisibility.Assembly:
                 case TypeMemberVisibility.FamilyAndAssembly:
-                    return context.IncludePrivateMembers || context.Module.SourceAssemblyOpt?.InternalsAreVisible == true;
+                    acceptBasedOnVisibility = context.IncludePrivateMembers || context.Module.SourceAssemblyOpt?.InternalsAreVisible == true;
+                    break;
+            }
+
+            if (acceptBasedOnVisibility)
+            {
+                return true;
             }
-            return true;
+
+            if (method?.IsStatic == true)
+            {
+                foreach (var methodImplementation in method.ContainingTypeDefinition.GetExplicitImplementationOverrides(context))
+                {
+                    if (methodImplementation.ImplementingMethod == method)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
         }
     }
 }
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
index 96e49d321b22f..24ba7a0146f1b 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
@@ -1158,7 +1158,6 @@ private BlobHandle GetMethodSignatureHandleAndBlob(IMethodReference methodRefere
 
             SerializeReturnValueAndParameters(encoder, methodReference, methodReference.ExtraParameters);
 
-
             signatureBlob = builder.ToImmutableArray();
             result = metadata.GetOrAddBlob(signatureBlob);
             _signatureIndex.Add(methodReference, KeyValuePairUtil.Create(result, signatureBlob));
@@ -2091,10 +2090,7 @@ private TypeReferenceHandle GetDummyAssemblyAttributeParent(bool isSecurity, boo
         private void AddModuleAttributesToTable(CommonPEModuleBuilder module)
         {
             Debug.Assert(this.IsFullMetadata);
-            foreach (ICustomAttribute customAttribute in module.GetSourceModuleAttributes())
-            {
-                AddCustomAttributeToTable(EntityHandle.ModuleDefinition, customAttribute);
-            }
+            AddCustomAttributesToTable(EntityHandle.ModuleDefinition, module.GetSourceModuleAttributes());
         }
 
         private void AddCustomAttributesToTable<T>(IEnumerable<T> parentList, TableIndex tableIndex)
@@ -2104,10 +2100,7 @@ private void AddCustomAttributesToTable<T>(IEnumerable<T> parentList, TableIndex
             foreach (var parent in parentList)
             {
                 var parentHandle = MetadataTokens.Handle(tableIndex, parentRowId++);
-                foreach (ICustomAttribute customAttribute in parent.GetAttributes(Context))
-                {
-                    AddCustomAttributeToTable(parentHandle, customAttribute);
-                }
+                AddCustomAttributesToTable(parentHandle, parent.GetAttributes(Context));
             }
         }
 
@@ -2117,33 +2110,19 @@ private void AddCustomAttributesToTable<T>(IEnumerable<T> parentList, Func<T, En
             foreach (var parent in parentList)
             {
                 EntityHandle parentHandle = getDefinitionHandle(parent);
-                foreach (ICustomAttribute customAttribute in parent.GetAttributes(Context))
-                {
-                    AddCustomAttributeToTable(parentHandle, customAttribute);
-                }
+                AddCustomAttributesToTable(parentHandle, parent.GetAttributes(Context));
             }
         }
 
-        private void AddCustomAttributesToTable(
-            EntityHandle handle,
-            ImmutableArray<ICustomAttribute> attributes)
+        protected virtual int AddCustomAttributesToTable(EntityHandle parentHandle, IEnumerable<ICustomAttribute> attributes)
         {
+            int count = 0;
             foreach (var attr in attributes)
             {
-                AddCustomAttributeToTable(handle, attr);
-            }
-        }
-
-        private void AddCustomAttributesToTable(IEnumerable<TypeReferenceWithAttributes> typeRefsWithAttributes)
-        {
-            foreach (var typeRefWithAttributes in typeRefsWithAttributes)
-            {
-                var ifaceHandle = GetTypeHandle(typeRefWithAttributes.TypeRef);
-                foreach (var customAttribute in typeRefWithAttributes.Attributes)
-                {
-                    AddCustomAttributeToTable(ifaceHandle, customAttribute);
-                }
+                count++;
+                AddCustomAttributeToTable(parentHandle, attr);
             }
+            return count;
         }
 
         private void AddCustomAttributeToTable(EntityHandle parentHandle, ICustomAttribute customAttribute)
@@ -2435,7 +2414,6 @@ private void PopulateFileTableRows()
             }
         }
 
-
         private void PopulateGenericParameters(
             ImmutableArray<IGenericParameter> sortedGenericParameters)
         {
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index 569874167b8fd..c245c3fbfd1c2 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -6,6 +6,10 @@ Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.UpdatedMethods.get -> System.Co
 Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.UpdatedTypes.get -> System.Collections.Immutable.ImmutableArray<System.Reflection.Metadata.TypeDefinitionHandle>
 Microsoft.CodeAnalysis.GeneratorAttribute.GeneratorAttribute(string! firstLanguage, params string![]! additionalLanguages) -> void
 Microsoft.CodeAnalysis.GeneratorAttribute.Languages.get -> string![]!
+Microsoft.CodeAnalysis.GeneratorDriver.ReplaceAdditionalText(Microsoft.CodeAnalysis.AdditionalText! oldText, Microsoft.CodeAnalysis.AdditionalText! newText) -> Microsoft.CodeAnalysis.GeneratorDriver!
+Microsoft.CodeAnalysis.GeneratorDriver.WithUpdatedAnalyzerConfigOptions(Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider! newOptions) -> Microsoft.CodeAnalysis.GeneratorDriver!
+Microsoft.CodeAnalysis.GeneratorDriver.WithUpdatedParseOptions(Microsoft.CodeAnalysis.ParseOptions! newOptions) -> Microsoft.CodeAnalysis.GeneratorDriver!
+Microsoft.CodeAnalysis.GeneratorExtensions
 Microsoft.CodeAnalysis.IFieldSymbol.IsExplicitlyNamedTupleElement.get -> bool
 Microsoft.CodeAnalysis.GeneratorExecutionContext.SyntaxContextReceiver.get -> Microsoft.CodeAnalysis.ISyntaxContextReceiver?
 Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForSyntaxNotifications(Microsoft.CodeAnalysis.SyntaxContextReceiverCreator! receiverCreator) -> void
@@ -13,7 +17,29 @@ Microsoft.CodeAnalysis.GeneratorSyntaxContext
 Microsoft.CodeAnalysis.GeneratorSyntaxContext.GeneratorSyntaxContext() -> void
 Microsoft.CodeAnalysis.GeneratorSyntaxContext.Node.get -> Microsoft.CodeAnalysis.SyntaxNode!
 Microsoft.CodeAnalysis.GeneratorSyntaxContext.SemanticModel.get -> Microsoft.CodeAnalysis.SemanticModel!
+Microsoft.CodeAnalysis.IIncrementalGenerator
+Microsoft.CodeAnalysis.IIncrementalGenerator.Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context) -> void
 Microsoft.CodeAnalysis.IMethodSymbol.IsPartialDefinition.get -> bool
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.AdditionalTextsProvider.get -> Microsoft.CodeAnalysis.IncrementalValuesProvider<Microsoft.CodeAnalysis.AdditionalText!>
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.AnalyzerConfigOptionsProvider.get -> Microsoft.CodeAnalysis.IncrementalValueProvider<Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider!>
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.CompilationProvider.get -> Microsoft.CodeAnalysis.IncrementalValueProvider<Microsoft.CodeAnalysis.Compilation!>
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.IncrementalGeneratorInitializationContext() -> void
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.ParseOptionsProvider.get -> Microsoft.CodeAnalysis.IncrementalValueProvider<Microsoft.CodeAnalysis.ParseOptions!>
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterPostInitializationOutput(System.Action<Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext>! callback) -> void
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterSourceOutput<TSource>(Microsoft.CodeAnalysis.IncrementalValueProvider<TSource> source, System.Action<Microsoft.CodeAnalysis.SourceProductionContext, TSource>! action) -> void
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterSourceOutput<TSource>(Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source, System.Action<Microsoft.CodeAnalysis.SourceProductionContext, TSource>! action) -> void
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.SyntaxProvider.get -> Microsoft.CodeAnalysis.SyntaxValueProvider
+Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext
+Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.AddSource(string! hintName, Microsoft.CodeAnalysis.Text.SourceText! sourceText) -> void
+Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.AddSource(string! hintName, string! source) -> void
+Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.CancellationToken.get -> System.Threading.CancellationToken
+Microsoft.CodeAnalysis.IncrementalGeneratorPostInitializationContext.IncrementalGeneratorPostInitializationContext() -> void
+Microsoft.CodeAnalysis.IncrementalValueProvider<TValue>
+Microsoft.CodeAnalysis.IncrementalValueProvider<TValue>.IncrementalValueProvider() -> void
+Microsoft.CodeAnalysis.IncrementalValueProviderExtensions
+Microsoft.CodeAnalysis.IncrementalValuesProvider<TValues>
+Microsoft.CodeAnalysis.IncrementalValuesProvider<TValues>.IncrementalValuesProvider() -> void
 Microsoft.CodeAnalysis.ISyntaxContextReceiver
 Microsoft.CodeAnalysis.ISyntaxContextReceiver.OnVisitSyntaxNode(Microsoft.CodeAnalysis.GeneratorSyntaxContext context) -> void
 Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForPostInitialization(System.Action<Microsoft.CodeAnalysis.GeneratorPostInitializationContext>! callback) -> void
@@ -24,20 +50,26 @@ Microsoft.CodeAnalysis.GeneratorPostInitializationContext.CancellationToken.get
 Microsoft.CodeAnalysis.GeneratorPostInitializationContext.GeneratorPostInitializationContext() -> void
 Microsoft.CodeAnalysis.IMethodSymbol.MethodImplementationFlags.get -> System.Reflection.MethodImplAttributes
 Microsoft.CodeAnalysis.ITypeSymbol.IsRecord.get -> bool
-Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.IsExhaustive.get -> bool
 Microsoft.CodeAnalysis.LineMapping
-Microsoft.CodeAnalysis.LineMapping.Deconstruct(out Microsoft.CodeAnalysis.Text.LinePositionSpan span, out Microsoft.CodeAnalysis.FileLinePositionSpan mappedSpan) -> void
+Microsoft.CodeAnalysis.LineMapping.CharacterOffset.get -> int?
 Microsoft.CodeAnalysis.LineMapping.Equals(Microsoft.CodeAnalysis.LineMapping other) -> bool
 Microsoft.CodeAnalysis.LineMapping.IsHidden.get -> bool
 Microsoft.CodeAnalysis.LineMapping.LineMapping() -> void
-Microsoft.CodeAnalysis.LineMapping.LineMapping(Microsoft.CodeAnalysis.Text.LinePositionSpan span, Microsoft.CodeAnalysis.FileLinePositionSpan mappedSpan) -> void
+Microsoft.CodeAnalysis.LineMapping.LineMapping(Microsoft.CodeAnalysis.Text.LinePositionSpan span, int? characterOffset, Microsoft.CodeAnalysis.FileLinePositionSpan mappedSpan) -> void
 Microsoft.CodeAnalysis.LineMapping.MappedSpan.get -> Microsoft.CodeAnalysis.FileLinePositionSpan
 Microsoft.CodeAnalysis.LineMapping.Span.get -> Microsoft.CodeAnalysis.Text.LinePositionSpan
 override Microsoft.CodeAnalysis.LineMapping.Equals(object? obj) -> bool
 override Microsoft.CodeAnalysis.LineMapping.GetHashCode() -> int
 override Microsoft.CodeAnalysis.LineMapping.ToString() -> string?
+Microsoft.CodeAnalysis.Operations.ISwitchExpressionOperation.IsExhaustive.get -> bool
 Microsoft.CodeAnalysis.Operations.OperationWalker<TArgument>
 Microsoft.CodeAnalysis.Operations.OperationWalker<TArgument>.OperationWalker() -> void
+Microsoft.CodeAnalysis.SourceProductionContext
+Microsoft.CodeAnalysis.SourceProductionContext.AddSource(string! hintName, Microsoft.CodeAnalysis.Text.SourceText! sourceText) -> void
+Microsoft.CodeAnalysis.SourceProductionContext.AddSource(string! hintName, string! source) -> void
+Microsoft.CodeAnalysis.SourceProductionContext.CancellationToken.get -> System.Threading.CancellationToken
+Microsoft.CodeAnalysis.SourceProductionContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic! diagnostic) -> void
+Microsoft.CodeAnalysis.SourceProductionContext.SourceProductionContext() -> void
 Microsoft.CodeAnalysis.SymbolDisplayPartKind.RecordClassName = 31 -> Microsoft.CodeAnalysis.SymbolDisplayPartKind
 const Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CompilationEnd = "CompilationEnd" -> string!
 Microsoft.CodeAnalysis.SymbolDisplayPartKind.RecordStructName = 32 -> Microsoft.CodeAnalysis.SymbolDisplayPartKind
@@ -46,6 +78,9 @@ Microsoft.CodeAnalysis.SyntaxNode.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxNo
 Microsoft.CodeAnalysis.SyntaxNode.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxNode? other) -> bool
 Microsoft.CodeAnalysis.SyntaxNodeOrToken.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxNodeOrToken other) -> bool
 Microsoft.CodeAnalysis.SyntaxToken.IsIncrementallyIdenticalTo(Microsoft.CodeAnalysis.SyntaxToken token) -> bool
+Microsoft.CodeAnalysis.SyntaxValueProvider
+Microsoft.CodeAnalysis.SyntaxValueProvider.CreateSyntaxProvider<T>(System.Func<Microsoft.CodeAnalysis.SyntaxNode!, System.Threading.CancellationToken, bool>! predicate, System.Func<Microsoft.CodeAnalysis.GeneratorSyntaxContext, System.Threading.CancellationToken, T>! transform) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<T>
+Microsoft.CodeAnalysis.SyntaxValueProvider.SyntaxValueProvider() -> void
 override Microsoft.CodeAnalysis.Text.TextChangeRange.ToString() -> string!
 static Microsoft.CodeAnalysis.CaseInsensitiveComparison.Compare(System.ReadOnlySpan<char> left, System.ReadOnlySpan<char> right) -> int
 static Microsoft.CodeAnalysis.CaseInsensitiveComparison.Equals(System.ReadOnlySpan<char> left, System.ReadOnlySpan<char> right) -> bool
@@ -55,8 +90,22 @@ override Microsoft.CodeAnalysis.Operations.OperationWalker<TArgument>.DefaultVis
 override Microsoft.CodeAnalysis.Operations.OperationWalker<TArgument>.Visit(Microsoft.CodeAnalysis.IOperation? operation, TArgument argument) -> object?
 static Microsoft.CodeAnalysis.FileLinePositionSpan.operator !=(Microsoft.CodeAnalysis.FileLinePositionSpan left, Microsoft.CodeAnalysis.FileLinePositionSpan right) -> bool
 static Microsoft.CodeAnalysis.FileLinePositionSpan.operator ==(Microsoft.CodeAnalysis.FileLinePositionSpan left, Microsoft.CodeAnalysis.FileLinePositionSpan right) -> bool
+static Microsoft.CodeAnalysis.GeneratorExtensions.AsSourceGenerator(this Microsoft.CodeAnalysis.IIncrementalGenerator! incrementalGenerator) -> Microsoft.CodeAnalysis.ISourceGenerator!
+static Microsoft.CodeAnalysis.GeneratorExtensions.GetGeneratorType(this Microsoft.CodeAnalysis.ISourceGenerator! generator) -> System.Type!
 static Microsoft.CodeAnalysis.LineMapping.operator !=(Microsoft.CodeAnalysis.LineMapping left, Microsoft.CodeAnalysis.LineMapping right) -> bool
 static Microsoft.CodeAnalysis.LineMapping.operator ==(Microsoft.CodeAnalysis.LineMapping left, Microsoft.CodeAnalysis.LineMapping right) -> bool
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Collect<TSource>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source) -> Microsoft.CodeAnalysis.IncrementalValueProvider<System.Collections.Immutable.ImmutableArray<TSource>>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine<TLeft, TRight>(this Microsoft.CodeAnalysis.IncrementalValueProvider<TLeft> provider1, Microsoft.CodeAnalysis.IncrementalValueProvider<TRight> provider2) -> Microsoft.CodeAnalysis.IncrementalValueProvider<(TLeft Left, TRight Right)>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine<TLeft, TRight>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TLeft> provider1, Microsoft.CodeAnalysis.IncrementalValueProvider<TRight> provider2) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<(TLeft Left, TRight Right)>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Select<TSource, TResult>(this Microsoft.CodeAnalysis.IncrementalValueProvider<TSource> source, System.Func<TSource, System.Threading.CancellationToken, TResult>! selector) -> Microsoft.CodeAnalysis.IncrementalValueProvider<TResult>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Select<TSource, TResult>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source, System.Func<TSource, System.Threading.CancellationToken, TResult>! selector) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<TResult>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany<TSource, TResult>(this Microsoft.CodeAnalysis.IncrementalValueProvider<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Collections.Generic.IEnumerable<TResult>!>! selector) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<TResult>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany<TSource, TResult>(this Microsoft.CodeAnalysis.IncrementalValueProvider<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Collections.Immutable.ImmutableArray<TResult>>! selector) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<TResult>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany<TSource, TResult>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Collections.Generic.IEnumerable<TResult>!>! selector) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<TResult>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.SelectMany<TSource, TResult>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Collections.Immutable.ImmutableArray<TResult>>! selector) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<TResult>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Where<TSource>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source, System.Func<TSource, bool>! predicate) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer<TSource>(this Microsoft.CodeAnalysis.IncrementalValueProvider<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>! comparer) -> Microsoft.CodeAnalysis.IncrementalValueProvider<TSource>
+static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer<TSource>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>! comparer) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource>
 virtual Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGenerators(string! language) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISourceGenerator!>
 virtual Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGeneratorsForAllLanguages() -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISourceGenerator!>
 abstract Microsoft.CodeAnalysis.Compilation.GetUsedAssemblyReferences(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.MetadataReference!>
diff --git a/src/Compilers/Core/Portable/SourceGeneration/AdditionalSourcesCollection.cs b/src/Compilers/Core/Portable/SourceGeneration/AdditionalSourcesCollection.cs
index a293b8e700e5b..07b8ef81d8e0e 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/AdditionalSourcesCollection.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/AdditionalSourcesCollection.cs
@@ -53,28 +53,24 @@ public void Add(string hintName, SourceText source)
                     && c != '{'
                     && c != '}')
                 {
-                    throw new ArgumentException(string.Format(CodeAnalysisResources.HintNameInvalidChar, c, i), nameof(hintName));
+                    throw new ArgumentException(string.Format(CodeAnalysisResources.HintNameInvalidChar, hintName, c, i), nameof(hintName));
                 }
             }
 
             hintName = AppendExtensionIfRequired(hintName);
             if (this.Contains(hintName))
             {
-                throw new ArgumentException(CodeAnalysisResources.HintNameUniquePerGenerator, nameof(hintName));
+                throw new ArgumentException(string.Format(CodeAnalysisResources.HintNameUniquePerGenerator, hintName), nameof(hintName));
             }
 
             if (source.Encoding is null)
             {
-                throw new ArgumentException(CodeAnalysisResources.SourceTextRequiresEncoding, nameof(source));
+                throw new ArgumentException(string.Format(CodeAnalysisResources.SourceTextRequiresEncoding, hintName), nameof(source));
             }
 
             _sourcesAdded.Add(new GeneratedSourceText(hintName, source));
         }
 
-        public void AddRange(ImmutableArray<GeneratedSourceText> texts) => _sourcesAdded.AddRange(texts);
-
-        public void AddRange(ImmutableArray<GeneratedSyntaxTree> trees) => _sourcesAdded.AddRange(trees.SelectAsArray(t => new GeneratedSourceText(t.HintName, t.Text)));
-
         public void RemoveSource(string hintName)
         {
             hintName = AppendExtensionIfRequired(hintName);
@@ -103,6 +99,10 @@ public bool Contains(string hintName)
 
         internal ImmutableArray<GeneratedSourceText> ToImmutableAndFree() => _sourcesAdded.ToImmutableAndFree();
 
+        internal ImmutableArray<GeneratedSourceText> ToImmutable() => _sourcesAdded.ToImmutable();
+
+        internal void Free() => _sourcesAdded.Free();
+
         private string AppendExtensionIfRequired(string hintName)
         {
             if (!hintName.EndsWith(_fileExtension, _hintNameComparison))
diff --git a/src/Compilers/Core/Portable/SourceGeneration/GeneratorAdaptor.cs b/src/Compilers/Core/Portable/SourceGeneration/GeneratorAdaptor.cs
new file mode 100644
index 0000000000000..745d74bdcae06
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/GeneratorAdaptor.cs
@@ -0,0 +1,77 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// Adapts an ISourceGenerator to an incremental generator that
+    /// by providing an execution environment that matches the old one
+    /// </summary>
+    internal sealed class SourceGeneratorAdaptor : IIncrementalGenerator
+    {
+        internal ISourceGenerator SourceGenerator { get; }
+
+        public SourceGeneratorAdaptor(ISourceGenerator generator)
+        {
+            SourceGenerator = generator;
+        }
+
+        public void Initialize(IncrementalGeneratorInitializationContext context)
+        {
+            GeneratorInitializationContext generatorInitContext = new GeneratorInitializationContext(CancellationToken.None);
+            SourceGenerator.Initialize(generatorInitContext);
+
+            if (generatorInitContext.InfoBuilder.PostInitCallback is object)
+            {
+                context.RegisterPostInitializationOutput(generatorInitContext.InfoBuilder.PostInitCallback);
+            }
+
+            var contextBuilderSource = context.CompilationProvider
+                                        .Select((c, _) => new GeneratorContextBuilder(c))
+                                        .Combine(context.ParseOptionsProvider).Select((p, _) => p.Item1 with { ParseOptions = p.Item2 })
+                                        .Combine(context.AnalyzerConfigOptionsProvider).Select((p, _) => p.Item1 with { ConfigOptions = p.Item2 })
+                                        .Combine(context.AdditionalTextsProvider.Collect()).Select((p, _) => p.Item1 with { AdditionalTexts = p.Item2 });
+
+            var syntaxContextReceiverCreator = generatorInitContext.InfoBuilder.SyntaxContextReceiverCreator;
+            if (syntaxContextReceiverCreator is object)
+            {
+                contextBuilderSource = contextBuilderSource
+                                       .Combine(context.SyntaxProvider.CreateSyntaxReceiverProvider(syntaxContextReceiverCreator))
+                                       .Select((p, _) => p.Item1 with { Receiver = p.Item2 });
+            }
+
+            context.RegisterSourceOutput(contextBuilderSource, (productionContext, contextBuilder) =>
+            {
+                var generatorExecutionContext = contextBuilder.ToExecutionContext(productionContext.CancellationToken);
+                SourceGenerator.Execute(generatorExecutionContext);
+
+                // copy the contents of the old context to the new
+                generatorExecutionContext.CopyToProductionContext(productionContext);
+                generatorExecutionContext.Free();
+            });
+        }
+
+        internal record GeneratorContextBuilder(Compilation Compilation)
+        {
+            public ParseOptions? ParseOptions;
+
+            public ImmutableArray<AdditionalText> AdditionalTexts;
+
+            public Diagnostics.AnalyzerConfigOptionsProvider? ConfigOptions;
+
+            public ISyntaxContextReceiver? Receiver;
+
+            public GeneratorExecutionContext ToExecutionContext(CancellationToken cancellationToken)
+            {
+                Debug.Assert(ParseOptions is object && ConfigOptions is object);
+                return new GeneratorExecutionContext(Compilation, ParseOptions, AdditionalTexts, ConfigOptions, Receiver, cancellationToken);
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/GeneratorContexts.cs b/src/Compilers/Core/Portable/SourceGeneration/GeneratorContexts.cs
index 8bc2ff98333a9..b639f593aa1bc 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/GeneratorContexts.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/GeneratorContexts.cs
@@ -7,6 +7,7 @@
 using System.Text;
 using System.Threading;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
 namespace Microsoft.CodeAnalysis
 {
@@ -17,9 +18,9 @@ public readonly struct GeneratorExecutionContext
     {
         private readonly DiagnosticBag _diagnostics;
 
-        private readonly AdditionalSourcesCollection _additionalSources;
+        private readonly ArrayBuilder<GeneratedSourceText> _additionalSources;
 
-        internal GeneratorExecutionContext(Compilation compilation, ParseOptions parseOptions, ImmutableArray<AdditionalText> additionalTexts, AnalyzerConfigOptionsProvider optionsProvider, ISyntaxContextReceiver? syntaxReceiver, AdditionalSourcesCollection additionalSources, CancellationToken cancellationToken = default)
+        internal GeneratorExecutionContext(Compilation compilation, ParseOptions parseOptions, ImmutableArray<AdditionalText> additionalTexts, AnalyzerConfigOptionsProvider optionsProvider, ISyntaxContextReceiver? syntaxReceiver, CancellationToken cancellationToken = default)
         {
             Compilation = compilation;
             ParseOptions = parseOptions;
@@ -28,7 +29,7 @@ internal GeneratorExecutionContext(Compilation compilation, ParseOptions parseOp
             SyntaxReceiver = (syntaxReceiver as SyntaxContextReceiverAdaptor)?.Receiver;
             SyntaxContextReceiver = (syntaxReceiver is SyntaxContextReceiverAdaptor) ? null : syntaxReceiver;
             CancellationToken = cancellationToken;
-            _additionalSources = additionalSources;
+            _additionalSources = ArrayBuilder<GeneratedSourceText>.GetInstance();
             _diagnostics = new DiagnosticBag();
         }
 
@@ -84,7 +85,7 @@ internal GeneratorExecutionContext(Compilation compilation, ParseOptions parseOp
         /// </summary>
         /// <param name="hintName">An identifier that can be used to reference this source text, must be unique within this generator</param>
         /// <param name="sourceText">The <see cref="SourceText"/> to add to the compilation</param>
-        public void AddSource(string hintName, SourceText sourceText) => _additionalSources.Add(hintName, sourceText);
+        public void AddSource(string hintName, SourceText sourceText) => _additionalSources.Add(new GeneratedSourceText(hintName, sourceText));
 
         /// <summary>
         /// Adds a <see cref="Diagnostic"/> to the users compilation 
@@ -97,6 +98,18 @@ internal GeneratorExecutionContext(Compilation compilation, ParseOptions parseOp
 
         internal (ImmutableArray<GeneratedSourceText> sources, ImmutableArray<Diagnostic> diagnostics) ToImmutableAndFree()
             => (_additionalSources.ToImmutableAndFree(), _diagnostics.ToReadOnlyAndFree());
+
+        internal void Free()
+        {
+            _additionalSources.Free();
+            _diagnostics.Free();
+        }
+
+        internal void CopyToProductionContext(SourceProductionContext ctx)
+        {
+            ctx.Sources.AddRange(_additionalSources);
+            ctx.Diagnostics.AddRange(_diagnostics);
+        }
     }
 
     /// <summary>
@@ -117,12 +130,6 @@ internal GeneratorInitializationContext(CancellationToken cancellationToken = de
 
         internal GeneratorInfo.Builder InfoBuilder { get; }
 
-        internal void RegisterForAdditionalFileChanges(EditCallback<AdditionalFileEdit> callback)
-        {
-            CheckIsEmpty(InfoBuilder.EditCallback);
-            InfoBuilder.EditCallback = callback;
-        }
-
         /// <summary>
         /// Register a <see cref="SyntaxReceiverCreator"/> for this generator, which can be used to create an instance of an <see cref="ISyntaxReceiver"/>.
         /// </summary>
@@ -178,13 +185,13 @@ public void RegisterForSyntaxNotifications(SyntaxContextReceiverCreator receiver
         /// For example a generator may choose to add sources during PostInitialization. These will be added to the compilation before execution and
         /// will be visited by a registered <see cref="ISyntaxReceiver"/> and available for semantic analysis as part of the <see cref="GeneratorExecutionContext.Compilation"/>
         /// 
-        /// Note that any sources added during PostInitialization <i>will</i> be visible to the later phases of other generators operation on the compilation. 
+        /// Note that any sources added during PostInitialization <i>will</i> be visible to the later phases of other generators operating on the compilation. 
         /// </remarks>
         /// <param name="callback">An <see cref="Action{T}"/> that accepts a <see cref="GeneratorPostInitializationContext"/> that will be invoked after initialization.</param>
         public void RegisterForPostInitialization(Action<GeneratorPostInitializationContext> callback)
         {
             CheckIsEmpty(InfoBuilder.PostInitCallback);
-            InfoBuilder.PostInitCallback = callback;
+            InfoBuilder.PostInitCallback = (context) => callback(new GeneratorPostInitializationContext(context.AdditionalSources, context.CancellationToken));
         }
 
         private static void CheckIsEmpty<T>(T x, string? typeName = null) where T : class?
@@ -250,17 +257,4 @@ internal GeneratorPostInitializationContext(AdditionalSourcesCollection addition
         /// <param name="sourceText">The <see cref="SourceText"/> to add to the compilation</param>
         public void AddSource(string hintName, SourceText sourceText) => _additionalSources.Add(hintName, sourceText);
     }
-
-    internal readonly struct GeneratorEditContext
-    {
-        internal GeneratorEditContext(AdditionalSourcesCollection sources, CancellationToken cancellationToken = default)
-        {
-            AdditionalSources = sources;
-            CancellationToken = cancellationToken;
-        }
-
-        public CancellationToken CancellationToken { get; }
-
-        public AdditionalSourcesCollection AdditionalSources { get; }
-    }
 }
diff --git a/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriver.cs b/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriver.cs
index e100917237d3a..bd44e07ae3d5a 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriver.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriver.cs
@@ -11,6 +11,7 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis
 {
@@ -21,15 +22,6 @@ namespace Microsoft.CodeAnalysis
     /// GeneratorDriver is an immutable class that can be manipulated by returning a mutated copy of itself.
     /// In the compiler we only ever create a single instance and ignore the mutated copy. The IDE may perform 
     /// multiple edits, or generation passes of the same driver, re-using the state as needed.
-    /// 
-    /// A generator driver works like a small state machine:
-    ///   - It starts off with no generated sources
-    ///   - A full generation pass will run every generator and produce all possible generated source
-    ///   - At any time an 'edit' maybe supplied, which represents potential future work
-    ///   - TryApplyChanges can be called, which will iterate through the pending edits and try and attempt to 
-    ///     bring the state back to what it would be if a full generation occurred by running partial generation
-    ///     on generators that support it
-    ///   - At any time a full generation pass can be re-run, resetting the pending edits
     /// </remarks>
     public abstract class GeneratorDriver
     {
@@ -37,13 +29,14 @@ public abstract class GeneratorDriver
 
         internal GeneratorDriver(GeneratorDriverState state)
         {
-            Debug.Assert(state.Generators.GroupBy(s => s.GetType()).Count() == state.Generators.Length); // ensure we don't have duplicate generator types
+            Debug.Assert(state.Generators.GroupBy(s => s.GetGeneratorType()).Count() == state.Generators.Length); // ensure we don't have duplicate generator types
             _state = state;
         }
 
-        internal GeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider optionsProvider, ImmutableArray<AdditionalText> additionalTexts)
+        internal GeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider optionsProvider, ImmutableArray<AdditionalText> additionalTexts, bool enableIncremental)
         {
-            _state = new GeneratorDriverState(parseOptions, optionsProvider, generators, additionalTexts, ImmutableArray.Create(new GeneratorState[generators.Length]), ImmutableArray<PendingEdit>.Empty, editsFailed: true);
+            (var filteredGenerators, var incrementalGenerators) = GetIncrementalGenerators(generators, enableIncremental);
+            _state = new GeneratorDriverState(parseOptions, optionsProvider, filteredGenerators, incrementalGenerators, additionalTexts, ImmutableArray.Create(new GeneratorState[filteredGenerators.Length]), DriverStateTable.Empty, enableIncremental);
         }
 
         public GeneratorDriver RunGenerators(Compilation compilation, CancellationToken cancellationToken = default)
@@ -57,45 +50,26 @@ public GeneratorDriver RunGeneratorsAndUpdateCompilation(Compilation compilation
             var diagnosticsBag = DiagnosticBag.GetInstance();
             var state = RunGeneratorsCore(compilation, diagnosticsBag, cancellationToken);
 
-            // build the final state, and return 
+            // build the output compilation
             diagnostics = diagnosticsBag.ToReadOnlyAndFree();
-            return BuildFinalCompilation(compilation, out outputCompilation, state, cancellationToken);
-        }
-
-        internal GeneratorDriver TryApplyEdits(Compilation compilation, out Compilation outputCompilation, out bool success, CancellationToken cancellationToken = default)
-        {
-            // if we can't apply any partial edits, just instantly return
-            if (_state.EditsFailed || _state.Edits.Length == 0)
-            {
-                outputCompilation = compilation;
-                success = !_state.EditsFailed;
-                return this;
-            }
-
-            // Apply any pending edits
-            var state = _state;
-            foreach (var edit in _state.Edits)
+            ArrayBuilder<SyntaxTree> trees = ArrayBuilder<SyntaxTree>.GetInstance();
+            foreach (var generatorState in state.GeneratorStates)
             {
-                state = ApplyPartialEdit(state, edit, cancellationToken);
-                if (state.EditsFailed)
-                {
-                    outputCompilation = compilation;
-                    success = false;
-                    return this;
-                }
+                trees.AddRange(generatorState.PostInitTrees.Select(t => t.Tree));
+                trees.AddRange(generatorState.GeneratedTrees.Select(t => t.Tree));
             }
+            outputCompilation = compilation.AddSyntaxTrees(trees);
+            trees.Free();
 
-            // remove the previously generated syntax trees
-            compilation = RemoveGeneratedSyntaxTrees(_state, compilation);
-
-            success = true;
-            return BuildFinalCompilation(compilation, out outputCompilation, state, cancellationToken);
+            return FromState(state);
         }
 
         public GeneratorDriver AddGenerators(ImmutableArray<ISourceGenerator> generators)
         {
-            // set editsFailed true, as we won't be able to apply edits with a new generator
-            var newState = _state.With(generators: _state.Generators.AddRange(generators), generatorStates: _state.GeneratorStates.AddRange(new GeneratorState[generators.Length]), editsFailed: true);
+            (var filteredGenerators, var incrementalGenerators) = GetIncrementalGenerators(generators, _state.EnableIncremental);
+            var newState = _state.With(sourceGenerators: _state.Generators.AddRange(filteredGenerators),
+                                       incrementalGenerators: _state.IncrementalGenerators.AddRange(incrementalGenerators),
+                                       generatorStates: _state.GeneratorStates.AddRange(new GeneratorState[filteredGenerators.Length]));
             return FromState(newState);
         }
 
@@ -103,17 +77,19 @@ public GeneratorDriver RemoveGenerators(ImmutableArray<ISourceGenerator> generat
         {
             var newGenerators = _state.Generators;
             var newStates = _state.GeneratorStates;
+            var newIncrementalGenerators = _state.IncrementalGenerators;
             for (int i = 0; i < newGenerators.Length; i++)
             {
                 if (generators.Contains(newGenerators[i]))
                 {
                     newGenerators = newGenerators.RemoveAt(i);
                     newStates = newStates.RemoveAt(i);
+                    newIncrementalGenerators = newIncrementalGenerators.RemoveAt(i);
                     i--;
                 }
             }
 
-            return FromState(_state.With(generators: newGenerators, generatorStates: newStates));
+            return FromState(_state.With(sourceGenerators: newGenerators, incrementalGenerators: newIncrementalGenerators, generatorStates: newStates));
         }
 
         public GeneratorDriver AddAdditionalTexts(ImmutableArray<AdditionalText> additionalTexts)
@@ -128,6 +104,29 @@ public GeneratorDriver RemoveAdditionalTexts(ImmutableArray<AdditionalText> addi
             return FromState(newState);
         }
 
+        public GeneratorDriver ReplaceAdditionalText(AdditionalText oldText, AdditionalText newText)
+        {
+            if (oldText is null)
+            {
+                throw new ArgumentNullException(nameof(oldText));
+            }
+            if (newText is null)
+            {
+                throw new ArgumentNullException(nameof(newText));
+            }
+
+            var newState = _state.With(additionalTexts: _state.AdditionalTexts.Replace(oldText, newText));
+            return FromState(newState);
+        }
+
+        public GeneratorDriver WithUpdatedParseOptions(ParseOptions newOptions) => newOptions is object
+                                                                                   ? FromState(_state.With(parseOptions: newOptions))
+                                                                                   : throw new ArgumentNullException(nameof(newOptions));
+
+        public GeneratorDriver WithUpdatedAnalyzerConfigOptions(AnalyzerConfigOptionsProvider newOptions) => newOptions is object
+                                                                                                             ? FromState(_state.With(optionsProvider: newOptions))
+                                                                                                             : throw new ArgumentNullException(nameof(newOptions));
+
         public GeneratorDriverRunResult GetRunResult()
         {
             var results = _state.Generators.ZipAsArray(
@@ -159,77 +158,65 @@ internal GeneratorDriverState RunGeneratorsCore(Compilation compilation, Diagnos
             // with no generators, there is no work to do
             if (_state.Generators.IsEmpty)
             {
-                return _state;
+                return _state.With(stateTable: DriverStateTable.Empty);
             }
 
             // run the actual generation
-            var state = StateWithPendingEditsApplied(_state);
+            var state = _state;
             var stateBuilder = ArrayBuilder<GeneratorState>.GetInstance(state.Generators.Length);
             var constantSourcesBuilder = ArrayBuilder<SyntaxTree>.GetInstance();
-            var walkerBuilder = ArrayBuilder<GeneratorSyntaxWalker?>.GetInstance(state.Generators.Length, fillWithValue: null); // we know there is at max 1 per generator
-            int receiverCount = 0;
+            var syntaxInputNodes = ArrayBuilder<ISyntaxInputNode>.GetInstance();
 
-            for (int i = 0; i < state.Generators.Length; i++)
+            for (int i = 0; i < state.IncrementalGenerators.Length; i++)
             {
-                var generator = state.Generators[i];
+                var generator = state.IncrementalGenerators[i];
                 var generatorState = state.GeneratorStates[i];
+                var sourceGenerator = state.Generators[i];
 
                 // initialize the generator if needed
-                if (!generatorState.Info.Initialized)
+                if (!generatorState.Initialized)
                 {
-                    var context = new GeneratorInitializationContext(cancellationToken);
+                    var outputBuilder = ArrayBuilder<IIncrementalGeneratorOutputNode>.GetInstance();
+                    var inputBuilder = ArrayBuilder<ISyntaxInputNode>.GetInstance();
+                    var postInitSources = ImmutableArray<GeneratedSyntaxTree>.Empty;
+                    var pipelineContext = new IncrementalGeneratorInitializationContext(inputBuilder, outputBuilder);
+
                     Exception? ex = null;
                     try
                     {
-                        generator.Initialize(context);
+                        generator.Initialize(pipelineContext);
                     }
                     catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
                     {
                         ex = e;
                     }
-                    generatorState = ex is null
-                                     ? new GeneratorState(context.InfoBuilder.ToImmutable())
-                                     : SetGeneratorException(MessageProvider, GeneratorState.Uninitialized, generator, ex, diagnosticsBag, isInit: true);
 
-                    // invoke the post init callback if requested
-                    if (generatorState.Info.PostInitCallback is object)
+                    var outputNodes = outputBuilder.ToImmutableAndFree();
+                    var inputNodes = inputBuilder.ToImmutableAndFree();
+
+                    // run post init
+                    if (ex is null)
                     {
-                        var sourcesCollection = this.CreateSourcesCollection();
-                        var postContext = new GeneratorPostInitializationContext(sourcesCollection, cancellationToken);
                         try
                         {
-                            generatorState.Info.PostInitCallback(postContext);
+                            IncrementalExecutionContext context = UpdateOutputs(outputNodes, IncrementalGeneratorOutputKind.PostInit, cancellationToken);
+                            postInitSources = ParseAdditionalSources(sourceGenerator, context.ToImmutableAndFree().sources, cancellationToken);
                         }
-                        catch (Exception e)
+                        catch (UserFunctionException e)
                         {
-                            ex = e;
+                            ex = e.InnerException;
                         }
-
-                        generatorState = ex is null
-                                         ? new GeneratorState(generatorState.Info, ParseAdditionalSources(generator, sourcesCollection.ToImmutableAndFree(), cancellationToken))
-                                         : SetGeneratorException(MessageProvider, generatorState, generator, ex, diagnosticsBag, isInit: true);
                     }
+
+                    generatorState = ex is null
+                                     ? new GeneratorState(generatorState.Info, postInitSources, inputNodes, outputNodes)
+                                     : SetGeneratorException(MessageProvider, generatorState, sourceGenerator, ex, diagnosticsBag, isInit: true);
                 }
 
-                // create the syntax receiver if requested
-                if (generatorState.Info.SyntaxContextReceiverCreator is object && generatorState.Exception is null)
+                // if the pipeline registered any syntax input nodes, record them
+                if (!generatorState.InputNodes.IsEmpty)
                 {
-                    ISyntaxContextReceiver? rx = null;
-                    try
-                    {
-                        rx = generatorState.Info.SyntaxContextReceiverCreator();
-                    }
-                    catch (Exception e)
-                    {
-                        generatorState = SetGeneratorException(MessageProvider, generatorState, generator, e, diagnosticsBag);
-                    }
-
-                    if (rx is object)
-                    {
-                        walkerBuilder.SetItem(i, new GeneratorSyntaxWalker(rx));
-                        generatorState = generatorState.WithReceiver(rx);
-                        receiverCount++;
-                    }
+                    syntaxInputNodes.AddRange(generatorState.InputNodes);
                 }
 
                 // record any constant sources
@@ -248,146 +235,50 @@ internal GeneratorDriverState RunGeneratorsCore(Compilation compilation, Diagnos
             }
             constantSourcesBuilder.Free();
 
-            // Run a syntax walk if any of the generators requested it
-            if (receiverCount > 0)
+            var driverStateBuilder = new DriverStateTable.Builder(compilation, _state, syntaxInputNodes.ToImmutableAndFree(), cancellationToken);
+            for (int i = 0; i < state.IncrementalGenerators.Length; i++)
             {
-                foreach (var tree in compilation.SyntaxTrees)
-                {
-                    var root = tree.GetRoot(cancellationToken);
-                    var semanticModel = compilation.GetSemanticModel(tree);
-
-                    // https://github.com/dotnet/roslyn/issues/42629: should be possible to parallelize this
-                    for (int i = 0; i < walkerBuilder.Count; i++)
-                    {
-                        var walker = walkerBuilder[i];
-                        if (walker is object)
-                        {
-                            try
-                            {
-                                walker.VisitWithModel(semanticModel, root);
-                            }
-                            catch (Exception e)
-                            {
-                                stateBuilder[i] = SetGeneratorException(MessageProvider, stateBuilder[i], state.Generators[i], e, diagnosticsBag);
-                                walkerBuilder.SetItem(i, null); // don't re-visit this walker for any other trees
-                            }
-                        }
-                    }
-                }
-            }
-            walkerBuilder.Free();
-
-            // https://github.com/dotnet/roslyn/issues/42629: should be possible to parallelize this
-            for (int i = 0; i < state.Generators.Length; i++)
-            {
-                var generator = state.Generators[i];
                 var generatorState = stateBuilder[i];
-
-                // don't try and generate if initialization or syntax walk failed
                 if (generatorState.Exception is object)
                 {
                     continue;
                 }
-                Debug.Assert(generatorState.Info.Initialized);
 
-                // we create a new context for each run of the generator. We'll never re-use existing state, only replace anything we have 
-                var context = new GeneratorExecutionContext(compilation, state.ParseOptions, state.AdditionalTexts.NullToEmpty(), state.OptionsProvider, generatorState.SyntaxReceiver, CreateSourcesCollection(), cancellationToken);
                 try
                 {
-                    generator.Execute(context);
+                    var context = UpdateOutputs(generatorState.OutputNodes, IncrementalGeneratorOutputKind.Source, cancellationToken, driverStateBuilder);
+                    (var sources, var generatorDiagnostics) = context.ToImmutableAndFree();
+                    generatorDiagnostics = FilterDiagnostics(compilation, generatorDiagnostics, driverDiagnostics: diagnosticsBag, cancellationToken);
+
+                    stateBuilder[i] = new GeneratorState(generatorState.Info, generatorState.PostInitTrees, generatorState.InputNodes, generatorState.OutputNodes, ParseAdditionalSources(state.Generators[i], sources, cancellationToken), generatorDiagnostics);
                 }
-                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
+                catch (UserFunctionException ufe)
                 {
-                    stateBuilder[i] = SetGeneratorException(MessageProvider, generatorState, generator, e, diagnosticsBag);
-                    continue;
+                    stateBuilder[i] = SetGeneratorException(MessageProvider, stateBuilder[i], state.Generators[i], ufe.InnerException, diagnosticsBag);
                 }
-
-                (var sources, var generatorDiagnostics) = context.ToImmutableAndFree();
-                generatorDiagnostics = FilterDiagnostics(compilation, generatorDiagnostics, driverDiagnostics: diagnosticsBag, cancellationToken);
-
-                stateBuilder[i] = new GeneratorState(generatorState.Info, generatorState.PostInitTrees, ParseAdditionalSources(generator, sources, cancellationToken), generatorDiagnostics);
             }
-            state = state.With(generatorStates: stateBuilder.ToImmutableAndFree());
-            return state;
-        }
-
-        // When we expose this publicly, remove arbitrary edit adding and replace with dedicated edit types
-        internal GeneratorDriver WithPendingEdits(ImmutableArray<PendingEdit> edits)
-        {
-            var newState = _state.With(edits: _state.Edits.AddRange(edits));
-            return FromState(newState);
-        }
 
-        private GeneratorDriverState ApplyPartialEdit(GeneratorDriverState state, PendingEdit edit, CancellationToken cancellationToken = default)
-        {
-            var initialState = state;
-
-            // see if any generators accept this particular edit
-            var stateBuilder = PooledDictionary<ISourceGenerator, GeneratorState>.GetInstance();
-            for (int i = 0; i < initialState.Generators.Length; i++)
-            {
-                var generator = initialState.Generators[i];
-                var generatorState = initialState.GeneratorStates[i];
-                if (edit.AcceptedBy(generatorState.Info))
-                {
-                    // attempt to apply the edit
-                    var previousSources = CreateSourcesCollection();
-                    previousSources.AddRange(generatorState.GeneratedTrees);
-                    var context = new GeneratorEditContext(previousSources, cancellationToken);
-                    var succeeded = edit.TryApply(generatorState.Info, context);
-                    if (!succeeded)
-                    {
-                        // we couldn't successfully apply this edit
-                        // return the original state noting we failed
-                        return initialState.With(editsFailed: true);
-                    }
-
-                    // update the state with the new edits
-                    var additionalSources = previousSources.ToImmutableAndFree();
-                    state = state.With(generatorStates: state.GeneratorStates.SetItem(i, new GeneratorState(generatorState.Info, generatorState.PostInitTrees, generatedTrees: ParseAdditionalSources(generator, additionalSources, cancellationToken), diagnostics: ImmutableArray<Diagnostic>.Empty)));
-                }
-            }
-            state = edit.Commit(state);
+            state = state.With(stateTable: driverStateBuilder.ToImmutable(), generatorStates: stateBuilder.ToImmutableAndFree());
             return state;
         }
 
-        private static GeneratorDriverState StateWithPendingEditsApplied(GeneratorDriverState state)
-        {
-            if (state.Edits.Length == 0)
-            {
-                return state;
-            }
-
-            foreach (var edit in state.Edits)
-            {
-                state = edit.Commit(state);
-            }
-            return state.With(edits: ImmutableArray<PendingEdit>.Empty, editsFailed: false);
-        }
-
-        private static Compilation RemoveGeneratedSyntaxTrees(GeneratorDriverState state, Compilation compilation)
+        private IncrementalExecutionContext UpdateOutputs(ImmutableArray<IIncrementalGeneratorOutputNode> outputNodes, IncrementalGeneratorOutputKind outputKind, CancellationToken cancellationToken, DriverStateTable.Builder? driverStateBuilder = null)
         {
-            ArrayBuilder<SyntaxTree> trees = ArrayBuilder<SyntaxTree>.GetInstance();
-            foreach (var generatorState in state.GeneratorStates)
+            IncrementalExecutionContext context = new IncrementalExecutionContext(driverStateBuilder, CreateSourcesCollection());
+            foreach (var outputNode in outputNodes)
             {
-                foreach (var generatedTree in generatorState.GeneratedTrees)
+                if (outputNode.Kind == outputKind)
                 {
-                    if (generatedTree.Tree is object && compilation.ContainsSyntaxTree(generatedTree.Tree))
-                    {
-                        trees.Add(generatedTree.Tree);
-                    }
+                    outputNode.AppendOutputs(context, cancellationToken);
                 }
             }
-
-            var comp = compilation.RemoveSyntaxTrees(trees);
-            trees.Free();
-            return comp;
+            return context;
         }
 
         private ImmutableArray<GeneratedSyntaxTree> ParseAdditionalSources(ISourceGenerator generator, ImmutableArray<GeneratedSourceText> generatedSources, CancellationToken cancellationToken)
         {
             var trees = ArrayBuilder<GeneratedSyntaxTree>.GetInstance(generatedSources.Length);
-            var type = generator.GetType();
+            var type = generator.GetGeneratorType();
             var prefix = GetFilePathPrefixForGenerator(generator);
             foreach (var source in generatedSources)
             {
@@ -397,22 +288,6 @@ private ImmutableArray<GeneratedSyntaxTree> ParseAdditionalSources(ISourceGenera
             return trees.ToImmutableAndFree();
         }
 
-        private GeneratorDriver BuildFinalCompilation(Compilation compilation, out Compilation outputCompilation, GeneratorDriverState state, CancellationToken cancellationToken)
-        {
-            ArrayBuilder<SyntaxTree> trees = ArrayBuilder<SyntaxTree>.GetInstance();
-            foreach (var generatorState in state.GeneratorStates)
-            {
-                trees.AddRange(generatorState.PostInitTrees.Select(t => t.Tree));
-                trees.AddRange(generatorState.GeneratedTrees.Select(t => t.Tree));
-            }
-            outputCompilation = compilation.AddSyntaxTrees(trees);
-            trees.Free();
-
-            state = state.With(edits: ImmutableArray<PendingEdit>.Empty,
-                               editsFailed: false);
-            return FromState(state);
-        }
-
         private static GeneratorState SetGeneratorException(CommonMessageProvider provider, GeneratorState generatorState, ISourceGenerator generator, Exception e, DiagnosticBag? diagnosticBag, bool isInit = false)
         {
             var errorCode = isInit ? provider.WRN_GeneratorFailedDuringInitialization : provider.WRN_GeneratorFailedDuringGeneration;
@@ -433,7 +308,7 @@ private static GeneratorState SetGeneratorException(CommonMessageProvider provid
                 isEnabledByDefault: true,
                 customTags: WellKnownDiagnosticTags.AnalyzerException);
 
-            var diagnostic = Diagnostic.Create(descriptor, Location.None, generator.GetType().Name, e.GetType().Name, e.Message);
+            var diagnostic = Diagnostic.Create(descriptor, Location.None, generator.GetGeneratorType().Name, e.GetType().Name, e.Message);
 
             diagnosticBag?.Add(diagnostic);
             return new GeneratorState(generatorState.Info, e, diagnostic);
@@ -456,10 +331,28 @@ private static ImmutableArray<Diagnostic> FilterDiagnostics(Compilation compilat
 
         internal static string GetFilePathPrefixForGenerator(ISourceGenerator generator)
         {
-            var type = generator.GetType();
+            var type = generator.GetGeneratorType();
             return Path.Combine(type.Assembly.GetName().Name ?? string.Empty, type.FullName!);
         }
 
+        private static (ImmutableArray<ISourceGenerator>, ImmutableArray<IIncrementalGenerator>) GetIncrementalGenerators(ImmutableArray<ISourceGenerator> generators, bool enableIncremental)
+        {
+            if (enableIncremental)
+            {
+                return (generators, generators.SelectAsArray(g => g switch
+                {
+                    IncrementalGeneratorWrapper igw => igw.Generator,
+                    IIncrementalGenerator ig => ig,
+                    _ => new SourceGeneratorAdaptor(g)
+                }));
+            }
+            else
+            {
+                var filtered = generators.WhereAsArray(g => g is not IncrementalGeneratorWrapper);
+                return (filtered, filtered.SelectAsArray<ISourceGenerator, IIncrementalGenerator>(g => new SourceGeneratorAdaptor(g)));
+            }
+        }
+
         internal abstract CommonMessageProvider MessageProvider { get; }
 
         internal abstract GeneratorDriver FromState(GeneratorDriverState state);
diff --git a/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriverState.cs b/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriverState.cs
index 40db4716ec888..bf62970bc92b9 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriverState.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriverState.cs
@@ -12,21 +12,23 @@ internal readonly struct GeneratorDriverState
     {
         internal GeneratorDriverState(ParseOptions parseOptions,
                                       AnalyzerConfigOptionsProvider optionsProvider,
-                                      ImmutableArray<ISourceGenerator> generators,
+                                      ImmutableArray<ISourceGenerator> sourceGenerators,
+                                      ImmutableArray<IIncrementalGenerator> incrementalGenerators,
                                       ImmutableArray<AdditionalText> additionalTexts,
                                       ImmutableArray<GeneratorState> generatorStates,
-                                      ImmutableArray<PendingEdit> edits,
-                                      bool editsFailed)
+                                      DriverStateTable stateTable,
+                                      bool enableIncremental)
         {
-            Generators = generators;
+            Generators = sourceGenerators;
+            IncrementalGenerators = incrementalGenerators;
             GeneratorStates = generatorStates;
             AdditionalTexts = additionalTexts;
-            Edits = edits;
             ParseOptions = parseOptions;
             OptionsProvider = optionsProvider;
-            EditsFailed = editsFailed;
-
+            StateTable = stateTable;
+            EnableIncremental = enableIncremental;
             Debug.Assert(Generators.Length == GeneratorStates.Length);
+            Debug.Assert(IncrementalGenerators.Length == GeneratorStates.Length);
         }
 
         /// <summary>
@@ -38,6 +40,15 @@ internal GeneratorDriverState(ParseOptions parseOptions,
         /// </remarks>
         internal readonly ImmutableArray<ISourceGenerator> Generators;
 
+        /// <summary>
+        /// The set of <see cref="IIncrementalGenerator"/>s associated with this state.
+        /// </summary>
+        /// <remarks>
+        /// This is the 'internal' representation of the <see cref="Generators"/> collection. There is a 1-to-1 mapping
+        /// where each entry is either the unwrapped incremental generator or a wrapped <see cref="ISourceGenerator"/>
+        /// </remarks>
+        internal readonly ImmutableArray<IIncrementalGenerator> IncrementalGenerators;
+
         /// <summary>
         /// The last run state of each generator, by the generator that created it
         /// </summary>
@@ -58,35 +69,38 @@ internal GeneratorDriverState(ParseOptions parseOptions,
         internal readonly AnalyzerConfigOptionsProvider OptionsProvider;
 
         /// <summary>
-        /// An ordered list of <see cref="PendingEdit"/>s that are waiting to be applied to the compilation.
+        /// ParseOptions to use when parsing generator provided source.
         /// </summary>
-        internal readonly ImmutableArray<PendingEdit> Edits;
+        internal readonly ParseOptions ParseOptions;
 
-        /// <summary>
-        /// Tracks if previous edits have failed to apply. A generator driver will not try and apply any edits when this flag is set.
-        /// </summary>
-        internal readonly bool EditsFailed;
+        internal readonly DriverStateTable StateTable;
 
         /// <summary>
-        /// ParseOptions to use when parsing generator provided source.
+        /// Should this driver run incremental generators or not
         /// </summary>
-        internal readonly ParseOptions ParseOptions;
+        /// <remarks>
+        /// Only used during preview period when incremental generators are enabled/disabled by preview flag
+        /// </remarks>
+        internal readonly bool EnableIncremental;
 
         internal GeneratorDriverState With(
-            ImmutableArray<ISourceGenerator>? generators = null,
+            ImmutableArray<ISourceGenerator>? sourceGenerators = null,
+            ImmutableArray<IIncrementalGenerator>? incrementalGenerators = null,
             ImmutableArray<GeneratorState>? generatorStates = null,
             ImmutableArray<AdditionalText>? additionalTexts = null,
-            ImmutableArray<PendingEdit>? edits = null,
-            bool? editsFailed = null)
+            DriverStateTable? stateTable = null,
+            ParseOptions? parseOptions = null,
+            AnalyzerConfigOptionsProvider? optionsProvider = null)
         {
             return new GeneratorDriverState(
-                this.ParseOptions,
-                this.OptionsProvider,
-                generators ?? this.Generators,
+                parseOptions ?? this.ParseOptions,
+                optionsProvider ?? this.OptionsProvider,
+                sourceGenerators ?? this.Generators,
+                incrementalGenerators ?? this.IncrementalGenerators,
                 additionalTexts ?? this.AdditionalTexts,
                 generatorStates ?? this.GeneratorStates,
-                edits ?? this.Edits,
-                editsFailed ?? this.EditsFailed
+                stateTable ?? this.StateTable,
+                this.EnableIncremental
                 );
         }
     }
diff --git a/src/Compilers/Core/Portable/SourceGeneration/GeneratorExtensions.cs b/src/Compilers/Core/Portable/SourceGeneration/GeneratorExtensions.cs
new file mode 100644
index 0000000000000..dd6dea79380f0
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/GeneratorExtensions.cs
@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.CodeAnalysis
+{
+    public static class GeneratorExtensions
+    {
+        /// <summary>
+        /// Returns the underlying type of a given generator
+        /// </summary>
+        /// <remarks>
+        /// For <see cref="IIncrementalGenerator"/>s a wrapper is created that also implements
+        /// <see cref="ISourceGenerator"/>. This method will unwrap and return the underlying type
+        /// in those cases.
+        /// </remarks>
+        /// <param name="generator">The generator to get the type of</param>
+        /// <returns>The underlying generator type</returns>
+        public static Type GetGeneratorType(this ISourceGenerator generator)
+        {
+            if (generator is IncrementalGeneratorWrapper igw)
+            {
+                return igw.Generator.GetType();
+            }
+            return generator.GetType();
+        }
+
+        /// <summary>
+        /// Converts an <see cref="IIncrementalGenerator"/> in an <see cref="ISourceGenerator"/> object that can be used when constructing a <see cref="GeneratorDriver"/>
+        /// </summary>
+        /// <param name="incrementalGenerator">The incremental generator to wrap</param>
+        /// <returns>A wrapped generator that can be passed to a generator driver</returns>
+        public static ISourceGenerator AsSourceGenerator(this IIncrementalGenerator incrementalGenerator) => new IncrementalGeneratorWrapper(incrementalGenerator);
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/GeneratorInfo.cs b/src/Compilers/Core/Portable/SourceGeneration/GeneratorInfo.cs
index 5121513433ffd..a66fe0f695f98 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/GeneratorInfo.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/GeneratorInfo.cs
@@ -8,31 +8,31 @@ namespace Microsoft.CodeAnalysis
 {
     internal readonly struct GeneratorInfo
     {
-        internal EditCallback<AdditionalFileEdit>? EditCallback { get; }
-
         internal SyntaxContextReceiverCreator? SyntaxContextReceiverCreator { get; }
 
-        internal Action<GeneratorPostInitializationContext>? PostInitCallback { get; }
+        internal Action<IncrementalGeneratorPostInitializationContext>? PostInitCallback { get; }
+
+        internal Action<IncrementalGeneratorInitializationContext>? PipelineCallback { get; }
 
         internal bool Initialized { get; }
 
-        internal GeneratorInfo(EditCallback<AdditionalFileEdit>? editCallback, SyntaxContextReceiverCreator? receiverCreator, Action<GeneratorPostInitializationContext>? postInitCallback)
+        internal GeneratorInfo(SyntaxContextReceiverCreator? receiverCreator, Action<IncrementalGeneratorPostInitializationContext>? postInitCallback, Action<IncrementalGeneratorInitializationContext>? pipelineCallback)
         {
-            EditCallback = editCallback;
             SyntaxContextReceiverCreator = receiverCreator;
             PostInitCallback = postInitCallback;
+            PipelineCallback = pipelineCallback;
             Initialized = true;
         }
 
         internal class Builder
         {
-            internal EditCallback<AdditionalFileEdit>? EditCallback { get; set; }
-
             internal SyntaxContextReceiverCreator? SyntaxContextReceiverCreator { get; set; }
 
-            internal Action<GeneratorPostInitializationContext>? PostInitCallback { get; set; }
+            internal Action<IncrementalGeneratorPostInitializationContext>? PostInitCallback { get; set; }
+
+            internal Action<IncrementalGeneratorInitializationContext>? PipelineCallback { get; set; }
 
-            public GeneratorInfo ToImmutable() => new GeneratorInfo(EditCallback, SyntaxContextReceiverCreator, PostInitCallback);
+            public GeneratorInfo ToImmutable() => new GeneratorInfo(SyntaxContextReceiverCreator, PostInitCallback, PipelineCallback);
         }
     }
 }
diff --git a/src/Compilers/Core/Portable/SourceGeneration/GeneratorState.cs b/src/Compilers/Core/Portable/SourceGeneration/GeneratorState.cs
index ade6ab61a95a2..bb32957b68036 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/GeneratorState.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/GeneratorState.cs
@@ -12,16 +12,11 @@ namespace Microsoft.CodeAnalysis
     /// </summary>
     internal readonly struct GeneratorState
     {
-        /// <summary>
-        /// Gets an uninitialized generator state
-        /// </summary>
-        internal static GeneratorState Uninitialized;
-
         /// <summary>
         /// Creates a new generator state that just contains information
         /// </summary>
         public GeneratorState(GeneratorInfo info)
-            : this(info, ImmutableArray<GeneratedSyntaxTree>.Empty, ImmutableArray<GeneratedSyntaxTree>.Empty, ImmutableArray<Diagnostic>.Empty, syntaxReceiver: null, exception: null)
+            : this(info, ImmutableArray<GeneratedSyntaxTree>.Empty)
         {
         }
 
@@ -29,7 +24,15 @@ public GeneratorState(GeneratorInfo info)
         /// Creates a new generator state that contains information and constant trees
         /// </summary>
         public GeneratorState(GeneratorInfo info, ImmutableArray<GeneratedSyntaxTree> postInitTrees)
-            : this(info, postInitTrees, ImmutableArray<GeneratedSyntaxTree>.Empty, ImmutableArray<Diagnostic>.Empty, syntaxReceiver: null, exception: null)
+            : this(info, postInitTrees, ImmutableArray<ISyntaxInputNode>.Empty, ImmutableArray<IIncrementalGeneratorOutputNode>.Empty)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new generator state that contains information, constant trees and an execution pipeline
+        /// </summary>
+        public GeneratorState(GeneratorInfo info, ImmutableArray<GeneratedSyntaxTree> postInitTrees, ImmutableArray<ISyntaxInputNode> inputNodes, ImmutableArray<IIncrementalGeneratorOutputNode> outputNodes)
+            : this(info, postInitTrees, inputNodes, outputNodes, ImmutableArray<GeneratedSyntaxTree>.Empty, ImmutableArray<Diagnostic>.Empty, exception: null)
         {
         }
 
@@ -37,52 +40,44 @@ public GeneratorState(GeneratorInfo info, ImmutableArray<GeneratedSyntaxTree> po
         /// Creates a new generator state that contains an exception and the associated diagnostic
         /// </summary>
         public GeneratorState(GeneratorInfo info, Exception e, Diagnostic error)
-            : this(info, ImmutableArray<GeneratedSyntaxTree>.Empty, ImmutableArray<GeneratedSyntaxTree>.Empty, ImmutableArray.Create(error), syntaxReceiver: null, exception: e)
+            : this(info, ImmutableArray<GeneratedSyntaxTree>.Empty, ImmutableArray<ISyntaxInputNode>.Empty, ImmutableArray<IIncrementalGeneratorOutputNode>.Empty, ImmutableArray<GeneratedSyntaxTree>.Empty, ImmutableArray.Create(error), exception: e)
         {
         }
 
         /// <summary>
         /// Creates a generator state that contains results
         /// </summary>
-        public GeneratorState(GeneratorInfo info, ImmutableArray<GeneratedSyntaxTree> postInitTrees, ImmutableArray<GeneratedSyntaxTree> generatedTrees, ImmutableArray<Diagnostic> diagnostics)
-            : this(info, postInitTrees, generatedTrees, diagnostics, syntaxReceiver: null, exception: null)
+        public GeneratorState(GeneratorInfo info, ImmutableArray<GeneratedSyntaxTree> postInitTrees, ImmutableArray<ISyntaxInputNode> inputNodes, ImmutableArray<IIncrementalGeneratorOutputNode> outputNodes, ImmutableArray<GeneratedSyntaxTree> generatedTrees, ImmutableArray<Diagnostic> diagnostics)
+            : this(info, postInitTrees, inputNodes, outputNodes, generatedTrees, diagnostics, exception: null)
         {
         }
 
-        private GeneratorState(GeneratorInfo info, ImmutableArray<GeneratedSyntaxTree> postInitTrees, ImmutableArray<GeneratedSyntaxTree> generatedTrees, ImmutableArray<Diagnostic> diagnostics, ISyntaxContextReceiver? syntaxReceiver, Exception? exception)
+        private GeneratorState(GeneratorInfo info, ImmutableArray<GeneratedSyntaxTree> postInitTrees, ImmutableArray<ISyntaxInputNode> inputNodes, ImmutableArray<IIncrementalGeneratorOutputNode> outputNodes, ImmutableArray<GeneratedSyntaxTree> generatedTrees, ImmutableArray<Diagnostic> diagnostics, Exception? exception)
         {
+            this.Initialized = true;
             this.PostInitTrees = postInitTrees;
+            this.InputNodes = inputNodes;
+            this.OutputNodes = outputNodes;
             this.GeneratedTrees = generatedTrees;
             this.Info = info;
             this.Diagnostics = diagnostics;
-            this.SyntaxReceiver = syntaxReceiver;
             this.Exception = exception;
         }
 
+        internal bool Initialized { get; }
+
         internal ImmutableArray<GeneratedSyntaxTree> PostInitTrees { get; }
 
+        internal ImmutableArray<ISyntaxInputNode> InputNodes { get; }
+
+        internal ImmutableArray<IIncrementalGeneratorOutputNode> OutputNodes { get; }
+
         internal ImmutableArray<GeneratedSyntaxTree> GeneratedTrees { get; }
 
         internal GeneratorInfo Info { get; }
 
-        internal ISyntaxContextReceiver? SyntaxReceiver { get; }
-
         internal Exception? Exception { get; }
 
         internal ImmutableArray<Diagnostic> Diagnostics { get; }
-
-        /// <summary>
-        /// Adds a syntax receiver to this generator state
-        /// </summary>
-        internal GeneratorState WithReceiver(ISyntaxContextReceiver syntaxReceiver)
-        {
-            Debug.Assert(this.Exception is null);
-            return new GeneratorState(this.Info,
-                                      postInitTrees: this.PostInitTrees,
-                                      generatedTrees: this.GeneratedTrees,
-                                      diagnostics: this.Diagnostics,
-                                      syntaxReceiver: syntaxReceiver,
-                                      exception: null);
-        }
     }
 }
diff --git a/src/Compilers/Core/Portable/SourceGeneration/IIncrementalGenerator.cs b/src/Compilers/Core/Portable/SourceGeneration/IIncrementalGenerator.cs
new file mode 100644
index 0000000000000..83737c6c7fc10
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/IIncrementalGenerator.cs
@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// The base interface required to implement an incremental generator
+    /// </summary>
+    /// <remarks>
+    /// The lifetime of a generator is controlled by the compiler.
+    /// State should not be stored directly on the generator, as there
+    /// is no guarantee that the same instance will be used on a 
+    /// subsequent generation pass.
+    /// </remarks>
+    public interface IIncrementalGenerator
+    {
+        /// <summary>
+        /// Called to initialize the generator and register generation steps via callbacks
+        /// on the <paramref name="context"/>
+        /// </summary>
+        /// <param name="context">The <see cref="IncrementalGeneratorInitializationContext"/> to register callbacks on</param>
+        void Initialize(IncrementalGeneratorInitializationContext context);
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs b/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs
new file mode 100644
index 0000000000000..974bf23eda19e
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs
@@ -0,0 +1,153 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// Context passed to an incremental generator when <see cref="IIncrementalGenerator.Initialize(IncrementalGeneratorInitializationContext)"/> is called
+    /// </summary>
+    public readonly struct IncrementalGeneratorInitializationContext
+    {
+        private readonly ArrayBuilder<ISyntaxInputNode> _syntaxInputBuilder;
+        private readonly ArrayBuilder<IIncrementalGeneratorOutputNode> _outputNodes;
+
+        internal IncrementalGeneratorInitializationContext(ArrayBuilder<ISyntaxInputNode> syntaxInputBuilder, ArrayBuilder<IIncrementalGeneratorOutputNode> outputNodes)
+        {
+            _syntaxInputBuilder = syntaxInputBuilder;
+            _outputNodes = outputNodes;
+        }
+
+        public SyntaxValueProvider SyntaxProvider => new SyntaxValueProvider(_syntaxInputBuilder, RegisterOutput);
+
+        public IncrementalValueProvider<Compilation> CompilationProvider => new IncrementalValueProvider<Compilation>(SharedInputNodes.Compilation.WithRegisterOutput(RegisterOutput));
+
+        public IncrementalValueProvider<ParseOptions> ParseOptionsProvider => new IncrementalValueProvider<ParseOptions>(SharedInputNodes.ParseOptions.WithRegisterOutput(RegisterOutput));
+
+        public IncrementalValuesProvider<AdditionalText> AdditionalTextsProvider => new IncrementalValuesProvider<AdditionalText>(SharedInputNodes.AdditionalTexts.WithRegisterOutput(RegisterOutput));
+
+        public IncrementalValueProvider<AnalyzerConfigOptionsProvider> AnalyzerConfigOptionsProvider => new IncrementalValueProvider<AnalyzerConfigOptionsProvider>(SharedInputNodes.AnalyzerConfigOptions.WithRegisterOutput(RegisterOutput));
+
+        public void RegisterSourceOutput<TSource>(IncrementalValueProvider<TSource> source, Action<SourceProductionContext, TSource> action) => source.Node.RegisterOutput(new SourceOutputNode<TSource>(source.Node, action.WrapUserAction()));
+
+        public void RegisterSourceOutput<TSource>(IncrementalValuesProvider<TSource> source, Action<SourceProductionContext, TSource> action) => source.Node.RegisterOutput(new SourceOutputNode<TSource>(source.Node, action.WrapUserAction()));
+
+        public void RegisterPostInitializationOutput(Action<IncrementalGeneratorPostInitializationContext> callback) => _outputNodes.Add(new PostInitOutputNode(callback.WrapUserAction()));
+
+        private void RegisterOutput(IIncrementalGeneratorOutputNode outputNode)
+        {
+            if (!_outputNodes.Contains(outputNode))
+            {
+                _outputNodes.Add(outputNode);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Context passed to an incremental generator when it has registered an output via <see cref="IncrementalGeneratorInitializationContext.RegisterPostInitializationOutput(Action{IncrementalGeneratorPostInitializationContext})"/>
+    /// </summary>
+    public readonly struct IncrementalGeneratorPostInitializationContext
+    {
+        internal readonly AdditionalSourcesCollection AdditionalSources;
+
+        internal IncrementalGeneratorPostInitializationContext(AdditionalSourcesCollection additionalSources, CancellationToken cancellationToken)
+        {
+            AdditionalSources = additionalSources;
+            CancellationToken = cancellationToken;
+        }
+
+        /// <summary>
+        /// A <see cref="System.Threading.CancellationToken"/> that can be checked to see if the PostInitialization should be cancelled.
+        /// </summary>
+        public CancellationToken CancellationToken { get; }
+
+        /// <summary>
+        /// Adds source code in the form of a <see cref="string"/> to the compilation that will be available during subsequent phases
+        /// </summary>
+        /// <param name="hintName">An identifier that can be used to reference this source text, must be unique within this generator</param>
+        /// <param name="source">The source code to add to the compilation</param>
+        public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8));
+
+        /// <summary>
+        /// Adds a <see cref="SourceText"/> to the compilation that will be available during subsequent phases
+        /// </summary>
+        /// <param name="hintName">An identifier that can be used to reference this source text, must be unique within this generator</param>
+        /// <param name="sourceText">The <see cref="SourceText"/> to add to the compilation</param>
+        public void AddSource(string hintName, SourceText sourceText) => AdditionalSources.Add(hintName, sourceText);
+    }
+
+    /// <summary>
+    /// Context passed to an incremental generator when it has registered an output via <see cref="IncrementalGeneratorInitializationContext.RegisterSourceOutput{TSource}(IncrementalValueProvider{TSource}, Action{SourceProductionContext, TSource})"/>
+    /// </summary>
+    public readonly struct SourceProductionContext
+    {
+        internal readonly ArrayBuilder<GeneratedSourceText> Sources;
+        internal readonly DiagnosticBag Diagnostics;
+
+        internal SourceProductionContext(ArrayBuilder<GeneratedSourceText> sources, DiagnosticBag diagnostics, CancellationToken cancellationToken)
+        {
+            CancellationToken = cancellationToken;
+            Sources = sources;
+            Diagnostics = diagnostics;
+        }
+
+        public CancellationToken CancellationToken { get; }
+
+        /// <summary>
+        /// Adds source code in the form of a <see cref="string"/> to the compilation.
+        /// </summary>
+        /// <param name="hintName">An identifier that can be used to reference this source text, must be unique within this generator</param>
+        /// <param name="source">The source code to add to the compilation</param>
+        public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8));
+
+        /// <summary>
+        /// Adds a <see cref="SourceText"/> to the compilation
+        /// </summary>
+        /// <param name="hintName">An identifier that can be used to reference this source text, must be unique within this generator</param>
+        /// <param name="sourceText">The <see cref="SourceText"/> to add to the compilation</param>
+        public void AddSource(string hintName, SourceText sourceText) => Sources.Add(new GeneratedSourceText(hintName, sourceText));
+
+        /// <summary>
+        /// Adds a <see cref="Diagnostic"/> to the users compilation 
+        /// </summary>
+        /// <param name="diagnostic">The diagnostic that should be added to the compilation</param>
+        /// <remarks>
+        /// The severity of the diagnostic may cause the compilation to fail, depending on the <see cref="Compilation"/> settings.
+        /// </remarks>
+        public void ReportDiagnostic(Diagnostic diagnostic) => Diagnostics.Add(diagnostic);
+    }
+
+    // https://github.com/dotnet/roslyn/issues/53608 right now we only support generating source + diagnostics, but actively want to support generation of other things
+    internal readonly struct IncrementalExecutionContext
+    {
+        internal readonly DiagnosticBag Diagnostics;
+
+        internal readonly AdditionalSourcesCollection Sources;
+
+        internal readonly DriverStateTable.Builder? TableBuilder;
+
+        public IncrementalExecutionContext(DriverStateTable.Builder? tableBuilder, AdditionalSourcesCollection sources)
+        {
+            TableBuilder = tableBuilder;
+            Sources = sources;
+            Diagnostics = DiagnosticBag.GetInstance();
+        }
+
+        internal (ImmutableArray<GeneratedSourceText> sources, ImmutableArray<Diagnostic> diagnostics) ToImmutableAndFree()
+                => (Sources.ToImmutableAndFree(), Diagnostics.ToReadOnlyAndFree());
+
+        internal void Free()
+        {
+            Sources.Free();
+            Diagnostics.Free();
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/IncrementalGeneratorSyntaxWalker.cs b/src/Compilers/Core/Portable/SourceGeneration/IncrementalGeneratorSyntaxWalker.cs
new file mode 100644
index 0000000000000..b4df0848178ae
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/IncrementalGeneratorSyntaxWalker.cs
@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis.PooledObjects;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class IncrementalGeneratorSyntaxWalker : SyntaxWalker
+    {
+        private readonly Func<SyntaxNode, CancellationToken, bool> _filter;
+        private readonly CancellationToken _token;
+        private ArrayBuilder<SyntaxNode>? _results;
+
+        internal IncrementalGeneratorSyntaxWalker(Func<SyntaxNode, CancellationToken, bool> filter, CancellationToken token)
+        {
+            _filter = filter;
+            _token = token;
+        }
+
+        public static ImmutableArray<SyntaxNode> GetFilteredNodes(SyntaxNode root, Func<SyntaxNode, CancellationToken, bool> func, CancellationToken token)
+        {
+            var walker = new IncrementalGeneratorSyntaxWalker(func, token);
+            walker.Visit(root);
+            return walker._results.ToImmutableOrEmptyAndFree();
+        }
+
+        public override void Visit(SyntaxNode node)
+        {
+            _token.ThrowIfCancellationRequested();
+
+            if (_filter(node, _token))
+            {
+                (_results ??= ArrayBuilder<SyntaxNode>.GetInstance()).Add(node);
+            }
+            base.Visit(node);
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/IncrementalValueProvider.cs b/src/Compilers/Core/Portable/SourceGeneration/IncrementalValueProvider.cs
new file mode 100644
index 0000000000000..ea40bf6e99335
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/IncrementalValueProvider.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// Represents a provider of a single value that can be transformed as part of constructing an execution pipeline
+    /// </summary>
+    /// <remarks>
+    /// This is an opaque type that cannot be used directly. Instead an <see cref="IIncrementalGenerator" />
+    /// will receive a set of value providers when constructing its execution pipeline. A set of extension methods
+    /// are then used to create transforms over the data that creates the actual pipeline.
+    /// </remarks>
+    /// <typeparam name="TValue">The type of value that this source provides access to</typeparam>
+    public readonly struct IncrementalValueProvider<TValue>
+    {
+        internal readonly IIncrementalGeneratorNode<TValue> Node;
+
+        internal IncrementalValueProvider(IIncrementalGeneratorNode<TValue> node)
+        {
+            this.Node = node;
+        }
+    }
+
+    /// <summary>
+    /// Represents a provider of multiple values that can be transformed to construct an execution pipeline
+    /// </summary>
+    /// <remarks>
+    /// This is an opaque type that cannot be used directly. Instead an <see cref="IIncrementalGenerator" />
+    /// will receive a set of value providers when constructing its execution pipeline. A set of extension methods
+    /// are then used to create transforms over the data that creates the actual pipeline.
+    /// </remarks>
+    /// <typeparam name="TValues">The type of value that this source provides access to</typeparam>
+    public readonly struct IncrementalValuesProvider<TValues>
+    {
+        internal readonly IIncrementalGeneratorNode<TValues> Node;
+
+        internal IncrementalValuesProvider(IIncrementalGeneratorNode<TValues> node)
+        {
+            this.Node = node;
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/IncrementalWrapper.cs b/src/Compilers/Core/Portable/SourceGeneration/IncrementalWrapper.cs
new file mode 100644
index 0000000000000..4b5970c3edca6
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/IncrementalWrapper.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// Wraps an incremental generator in a dummy <see cref="ISourceGenerator"/> interface.
+    /// </summary>
+    /// <remarks>
+    /// Allows us to treat both generator types as ISourceGenerator externally and not change the public API.
+    /// Inside the driver we unwrap and use the actual generator instance.
+    /// </remarks>
+    internal sealed class IncrementalGeneratorWrapper : ISourceGenerator
+    {
+        internal IIncrementalGenerator Generator { get; }
+
+        public IncrementalGeneratorWrapper(IIncrementalGenerator generator)
+        {
+            this.Generator = generator;
+        }
+
+        // never used. Just for back compat with loading mechanisim
+        void ISourceGenerator.Execute(GeneratorExecutionContext context) => throw ExceptionUtilities.Unreachable;
+
+        void ISourceGenerator.Initialize(GeneratorInitializationContext context) => throw ExceptionUtilities.Unreachable;
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs
new file mode 100644
index 0000000000000..031c7a7957053
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs
@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class BatchNode<TInput> : IIncrementalGeneratorNode<ImmutableArray<TInput>>
+    {
+        private readonly IIncrementalGeneratorNode<TInput> _sourceNode;
+        private readonly IEqualityComparer<ImmutableArray<TInput>> _comparer;
+
+        public BatchNode(IIncrementalGeneratorNode<TInput> sourceNode, IEqualityComparer<ImmutableArray<TInput>>? comparer = null)
+        {
+            _sourceNode = sourceNode;
+            _comparer = comparer ?? EqualityComparer<ImmutableArray<TInput>>.Default;
+        }
+
+        public IIncrementalGeneratorNode<ImmutableArray<TInput>> WithComparer(IEqualityComparer<ImmutableArray<TInput>> comparer) => new BatchNode<TInput>(_sourceNode, comparer);
+
+        public NodeStateTable<ImmutableArray<TInput>> UpdateStateTable(DriverStateTable.Builder builder, NodeStateTable<ImmutableArray<TInput>> previousTable, CancellationToken cancellationToken)
+        {
+            // grab the source inputs
+            var sourceTable = builder.GetLatestStateTableForNode(_sourceNode);
+
+            // Semantics of a batch transform:
+            // Batches will always exist (a batch of the empty table is still [])
+            // There is only ever one input, the batch of the upstream table
+            // - Output is cached when upstream is all cached
+            // - Added when the previous table was empty
+            // - Modified otherwise
+
+            var source = ImmutableArray.Create(sourceTable.Batch());
+
+            // update the table 
+            var newTable = previousTable.ToBuilder();
+            if (!newTable.TryModifyEntries(source, _comparer))
+            {
+                newTable.AddEntries(source, EntryState.Added);
+            }
+
+            return newTable.ToImmutableAndFree();
+        }
+
+        public void RegisterOutput(IIncrementalGeneratorOutputNode output) => _sourceNode.RegisterOutput(output);
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs
new file mode 100644
index 0000000000000..fd3156bd28a46
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs
@@ -0,0 +1,79 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class CombineNode<TInput1, TInput2> : IIncrementalGeneratorNode<(TInput1, TInput2)>
+    {
+        private readonly IIncrementalGeneratorNode<TInput1> _input1;
+        private readonly IIncrementalGeneratorNode<TInput2> _input2;
+        private readonly IEqualityComparer<(TInput1, TInput2)>? _comparer;
+
+        public CombineNode(IIncrementalGeneratorNode<TInput1> input1, IIncrementalGeneratorNode<TInput2> input2, IEqualityComparer<(TInput1, TInput2)>? comparer = null)
+        {
+            _input1 = input1;
+            _input2 = input2;
+            _comparer = comparer;
+        }
+
+        public NodeStateTable<(TInput1, TInput2)> UpdateStateTable(DriverStateTable.Builder graphState, NodeStateTable<(TInput1, TInput2)> previousTable, CancellationToken cancellationToken)
+        {
+            // get both input tables
+            var input1Table = graphState.GetLatestStateTableForNode(_input1);
+            var input2Table = graphState.GetLatestStateTableForNode(_input2);
+
+            if (input1Table.IsCached && input2Table.IsCached)
+            {
+                return previousTable;
+            }
+
+            var builder = previousTable.ToBuilder();
+
+            // Semantics of a join:
+            //
+            // When input1[i] is cached:
+            //  - cached if input2 is also cached
+            //  - modified otherwise
+            // State of input1[i] otherwise.
+
+            // get the input2 item
+            var isInput2Cached = input2Table.IsCached;
+            TInput2 input2 = input2Table.Single();
+
+            // append the input2 item to each item in input1 
+            foreach (var entry1 in input1Table)
+            {
+                var state = (entry1.state, isInput2Cached) switch
+                {
+                    (EntryState.Cached, true) => EntryState.Cached,
+                    (EntryState.Cached, false) => EntryState.Modified,
+                    _ => entry1.state
+                };
+
+                var entry = (entry1.item, input2);
+                if (state != EntryState.Modified || _comparer is null || !builder.TryModifyEntry(entry, _comparer))
+                {
+                    builder.AddEntry(entry, state);
+                }
+            }
+
+            return builder.ToImmutableAndFree();
+        }
+
+        public IIncrementalGeneratorNode<(TInput1, TInput2)> WithComparer(IEqualityComparer<(TInput1, TInput2)> comparer) => new CombineNode<TInput1, TInput2>(_input1, _input2, comparer);
+
+        public void RegisterOutput(IIncrementalGeneratorOutputNode output)
+        {
+            // We have to call register on both branches of the join, as they may chain up to different input nodes
+            _input1.RegisterOutput(output);
+            _input2.RegisterOutput(output);
+        }
+
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/DriverStateTable.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/DriverStateTable.cs
new file mode 100644
index 0000000000000..080e57b458756
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/DriverStateTable.cs
@@ -0,0 +1,141 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using Microsoft.CodeAnalysis.PooledObjects;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class DriverStateTable
+    {
+        private readonly ImmutableDictionary<object, IStateTable> _tables;
+
+        internal static DriverStateTable Empty { get; } = new DriverStateTable(ImmutableDictionary<object, IStateTable>.Empty);
+
+        private DriverStateTable(ImmutableDictionary<object, IStateTable> tables)
+        {
+            _tables = tables;
+        }
+
+        public NodeStateTable<T> GetStateTableOrEmpty<T>(object input)
+        {
+            if (_tables.TryGetValue(input, out var result))
+            {
+                return (NodeStateTable<T>)result;
+            }
+            return NodeStateTable<T>.Empty;
+        }
+
+        public sealed class Builder
+        {
+            private readonly ImmutableDictionary<object, IStateTable>.Builder _tableBuilder = ImmutableDictionary.CreateBuilder<object, IStateTable>();
+            private readonly ImmutableArray<ISyntaxInputNode> _syntaxInputNodes;
+            private readonly ImmutableDictionary<ISyntaxInputNode, Exception>.Builder _syntaxExceptions = ImmutableDictionary.CreateBuilder<ISyntaxInputNode, Exception>();
+            private readonly DriverStateTable _previousTable;
+            private readonly CancellationToken _cancellationToken;
+
+            internal GeneratorDriverState DriverState { get; }
+
+            public Compilation Compilation { get; }
+
+            public Builder(Compilation compilation, GeneratorDriverState driverState, ImmutableArray<ISyntaxInputNode> syntaxInputNodes, CancellationToken cancellationToken = default)
+            {
+                Compilation = compilation;
+                DriverState = driverState;
+                _previousTable = driverState.StateTable;
+                _syntaxInputNodes = syntaxInputNodes;
+                _cancellationToken = cancellationToken;
+            }
+
+            public IStateTable GetSyntaxInputTable(ISyntaxInputNode syntaxInputNode)
+            {
+                Debug.Assert(_syntaxInputNodes.Contains(syntaxInputNode));
+
+                // when we don't have a value for this node, we update all the syntax inputs at once
+                if (!_tableBuilder.ContainsKey(syntaxInputNode))
+                {
+                    // get a builder for each input node
+                    var builders = ArrayBuilder<ISyntaxInputBuilder>.GetInstance(_syntaxInputNodes.Length);
+                    foreach (var node in _syntaxInputNodes)
+                    {
+                        builders.Add(node.GetBuilder(_previousTable));
+                    }
+
+                    // update each tree for the builders, sharing the semantic model
+                    foreach ((var tree, var state) in GetLatestStateTableForNode(SharedInputNodes.SyntaxTrees))
+                    {
+                        var root = tree.GetRoot(_cancellationToken);
+                        var model = state != EntryState.Removed ? Compilation.GetSemanticModel(tree) : null;
+                        for (int i = 0; i < builders.Count; i++)
+                        {
+                            try
+                            {
+                                _cancellationToken.ThrowIfCancellationRequested();
+                                builders[i].VisitTree(root, state, model, _cancellationToken);
+                            }
+                            catch (UserFunctionException ufe)
+                            {
+                                // we're evaluating this node ahead of time, so we can't just throw the exception
+                                // instead we'll hold onto it, and throw the exception when a downstream node actually
+                                // attempts to read the value
+                                _syntaxExceptions[builders[i].SyntaxInputNode] = ufe;
+                                builders.RemoveAt(i);
+                                i--;
+                            }
+                        }
+                    }
+
+                    // save the updated inputs
+                    foreach (var builder in builders)
+                    {
+                        builder.SaveStateAndFree(_tableBuilder);
+                        Debug.Assert(_tableBuilder.ContainsKey(builder.SyntaxInputNode));
+                    }
+                    builders.Free();
+                }
+
+                // if we don't have an entry for this node, it must have thrown an exception
+                if (!_tableBuilder.ContainsKey(syntaxInputNode))
+                {
+                    throw _syntaxExceptions[syntaxInputNode];
+                }
+
+                return _tableBuilder[syntaxInputNode];
+            }
+
+            public NodeStateTable<T> GetLatestStateTableForNode<T>(IIncrementalGeneratorNode<T> source)
+            {
+                // if we've already evaluated a node during this build, we can just return the existing result
+                if (_tableBuilder.ContainsKey(source))
+                {
+                    return (NodeStateTable<T>)_tableBuilder[source];
+                }
+
+                // get the previous table, if there was one for this node
+                NodeStateTable<T> previousTable = _previousTable.GetStateTableOrEmpty<T>(source);
+
+                // request the node update its state based on the current driver table and store the new result
+                var newTable = source.UpdateStateTable(this, previousTable, _cancellationToken);
+                _tableBuilder[source] = newTable;
+                return newTable;
+            }
+
+            public DriverStateTable ToImmutable()
+            {
+                // we can compact the tables at this point, as we'll no longer be using them to determine current state
+                var keys = _tableBuilder.Keys.ToArray();
+                foreach (var key in keys)
+                {
+                    _tableBuilder[key] = _tableBuilder[key].AsCached();
+                }
+
+                return new DriverStateTable(_tableBuilder.ToImmutable());
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/IIncrementalGeneratorNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/IIncrementalGeneratorNode.cs
new file mode 100644
index 0000000000000..de014d6b16573
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/IIncrementalGeneratorNode.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// Represents a node in the execution pipeline of an incremental generator
+    /// </summary>
+    /// <typeparam name="T">The type of value this step operates on</typeparam>
+    internal interface IIncrementalGeneratorNode<T>
+    {
+        NodeStateTable<T> UpdateStateTable(DriverStateTable.Builder graphState, NodeStateTable<T> previousTable, CancellationToken cancellationToken);
+
+        IIncrementalGeneratorNode<T> WithComparer(IEqualityComparer<T> comparer);
+
+        void RegisterOutput(IIncrementalGeneratorOutputNode output);
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/IIncrementalGeneratorOutputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/IIncrementalGeneratorOutputNode.cs
new file mode 100644
index 0000000000000..22b35d6052587
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/IIncrementalGeneratorOutputNode.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// Internal representation of an incremental output
+    /// </summary>
+    internal interface IIncrementalGeneratorOutputNode
+    {
+        IncrementalGeneratorOutputKind Kind { get; }
+
+        void AppendOutputs(IncrementalExecutionContext context, CancellationToken cancellationToken);
+    }
+
+    internal enum IncrementalGeneratorOutputKind
+    {
+        Source,
+        PostInit
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/ISyntaxInputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/ISyntaxInputNode.cs
new file mode 100644
index 0000000000000..bf63515a1216f
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/ISyntaxInputNode.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal interface ISyntaxInputNode
+    {
+        ISyntaxInputBuilder GetBuilder(DriverStateTable table);
+    }
+
+    internal interface ISyntaxInputBuilder
+    {
+        ISyntaxInputNode SyntaxInputNode { get; }
+
+        void VisitTree(SyntaxNode root, EntryState state, SemanticModel? model, CancellationToken cancellationToken);
+
+        void SaveStateAndFree(ImmutableDictionary<object, IStateTable>.Builder tables);
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs
new file mode 100644
index 0000000000000..e0dcf34415c8d
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs
@@ -0,0 +1,92 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Threading;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// Input nodes are the 'root' nodes in the graph, and get their values from the inputs of the driver state table
+    /// </summary>
+    /// <typeparam name="T">The type of the input</typeparam>
+    internal sealed class InputNode<T> : IIncrementalGeneratorNode<T>
+    {
+        private readonly Func<DriverStateTable.Builder, ImmutableArray<T>> _getInput;
+        private readonly Action<IIncrementalGeneratorOutputNode> _registerOutput;
+        private readonly IEqualityComparer<T> _comparer;
+
+        public InputNode(Func<DriverStateTable.Builder, ImmutableArray<T>> getInput)
+            : this(getInput, registerOutput: null, comparer: null)
+        {
+        }
+
+        private InputNode(Func<DriverStateTable.Builder, ImmutableArray<T>> getInput, Action<IIncrementalGeneratorOutputNode>? registerOutput, IEqualityComparer<T>? comparer = null)
+        {
+            _getInput = getInput;
+            _comparer = comparer ?? EqualityComparer<T>.Default;
+            _registerOutput = registerOutput ?? (o => throw ExceptionUtilities.Unreachable);
+        }
+
+        public NodeStateTable<T> UpdateStateTable(DriverStateTable.Builder graphState, NodeStateTable<T> previousTable, CancellationToken cancellationToken)
+        {
+            var inputItems = _getInput(graphState);
+
+            // create a mutable hashset of the new items we can check against
+            HashSet<T> itemsSet = new HashSet<T>(_comparer);
+            foreach (var item in inputItems)
+            {
+                var added = itemsSet.Add(item);
+                Debug.Assert(added);
+            }
+
+            var builder = previousTable.ToBuilder();
+
+            // for each item in the previous table, check if its still in the new items
+            int itemIndex = 0;
+            foreach ((var oldItem, _) in previousTable)
+            {
+                if (itemsSet.Remove(oldItem))
+                {
+                    // we're iterating the table, so know that it has entries
+                    var usedCache = builder.TryUseCachedEntries();
+                    Debug.Assert(usedCache);
+                }
+                else if (inputItems.Length == previousTable.Count)
+                {
+                    // When the number of items matches the previous iteration, we use a heuristic to mark the input as modified
+                    // This allows us to correctly 'replace' items even when they aren't actually the same. In the case that the
+                    // item really isn't modified, but a new item, we still function correctly as we mostly treat them the same,
+                    // but will perform an extra comparison that is omitted in the pure 'added' case.
+                    var modified = builder.TryModifyEntry(inputItems[itemIndex], _comparer);
+                    Debug.Assert(modified);
+                    itemsSet.Remove(inputItems[itemIndex]);
+                }
+                else
+                {
+                    builder.RemoveEntries();
+                }
+                itemIndex++;
+            }
+
+            // any remaining new items are added
+            foreach (var newItem in itemsSet)
+            {
+                builder.AddEntry(newItem, EntryState.Added);
+            }
+
+            return builder.ToImmutableAndFree();
+        }
+
+        public IIncrementalGeneratorNode<T> WithComparer(IEqualityComparer<T> comparer) => new InputNode<T>(_getInput, _registerOutput, comparer);
+
+        public InputNode<T> WithRegisterOutput(Action<IIncrementalGeneratorOutputNode> registerOutput) => new InputNode<T>(_getInput, registerOutput, _comparer);
+
+        public void RegisterOutput(IIncrementalGeneratorOutputNode output) => _registerOutput(output);
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeStateTable.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeStateTable.cs
new file mode 100644
index 0000000000000..5b7d5356795a0
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeStateTable.cs
@@ -0,0 +1,366 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis
+{
+    // A node table is the fundamental structure we use to track changes through the incremental 
+    // generator api. It can be thought of as a series of slots that take their input from an
+    // upstream table and produce 0-or-more outputs. When viewed from a downstream table the outputs
+    // are presented as a single unified list, with each output forming the new input to the downstream
+    // table.
+    // 
+    // Each slot has an associated state which is used to inform the operation that should be performed
+    // to create or update the outputs. States generally flow through from upstream to downstream tables.
+    // For instance an Added state implies that the upstream table produced a value that was not seen 
+    // in the previous iteration, and the table should run whatever transform it tracks on the input 
+    // to produce the outputs. These new outputs will also have a state of Added. A cached input specifies
+    // that the input has not changed, and thus the outputs will be the same as the previous run. Added,
+    // and Modified inputs will always run a transform to produce new outputs. Cached and Removed
+    // entries will always use the previous entries and perform no work.
+    // 
+    // It is important to track Removed entries while updating the downstream tables, as an upstream 
+    // remove can result in multiple downstream entries being removed. However, once all tables are up 
+    // to date, the removed entries are no longer needed, and the remaining entries can be considered to
+    // be cached. This process is called 'compaction' and results in the actual tables which are stored
+    // between runs, as opposed to the 'live' tables that exist during an update.
+    //
+    // Modified entries are similar to added inputs, but with a subtle difference. When an input is Added
+    // all outputs are unconditionally added too. However when an input is modified, the outputs may still
+    // be the same (for instance something changed elsewhere in a file that had no bearing on the produced
+    // output). In this case, the state table checks the results against the previously produced values,
+    // and any that are found to be the same instead get a cached state, meaning no new downstream work 
+    // will be produced for them. Thus a modified input is the only slot that can have differing output 
+    // states.
+
+    internal enum EntryState { Added, Removed, Modified, Cached };
+
+    internal interface IStateTable
+    {
+        IStateTable AsCached();
+    }
+
+    /// <summary>
+    /// A data structure that tracks the inputs and output of an execution node
+    /// </summary>
+    /// <typeparam name="T">The type of the items tracked by this table</typeparam>
+    internal sealed class NodeStateTable<T> : IStateTable
+    {
+        internal static NodeStateTable<T> Empty { get; } = new NodeStateTable<T>(ImmutableArray<TableEntry>.Empty, isCompacted: true);
+
+        private readonly ImmutableArray<TableEntry> _states;
+
+
+        private NodeStateTable(ImmutableArray<TableEntry> states, bool isCompacted)
+        {
+            Debug.Assert(!isCompacted || states.All(s => s.IsCached));
+
+            _states = states;
+            IsCached = isCompacted;
+        }
+
+        public int Count { get => _states.Length; }
+
+        /// <summary>
+        /// Indicates if every entry in this table has a state of <see cref="EntryState.Cached"/>
+        /// </summary>
+        public bool IsCached { get; }
+
+        public IEnumerator<(T item, EntryState state)> GetEnumerator()
+        {
+            foreach (var inputEntry in _states)
+            {
+                for (int i = 0; i < inputEntry.Count; i++)
+                {
+                    yield return (inputEntry.GetItem(i), inputEntry.GetState(i));
+                }
+            }
+        }
+
+        public NodeStateTable<T> AsCached()
+        {
+            if (IsCached)
+                return this;
+
+            var compacted = ArrayBuilder<TableEntry>.GetInstance();
+            foreach (var entry in _states)
+            {
+                if (!entry.IsRemoved)
+                {
+                    compacted.Add(entry.AsCached());
+                }
+            }
+            return new NodeStateTable<T>(compacted.ToImmutableAndFree(), isCompacted: true);
+        }
+
+        IStateTable IStateTable.AsCached() => AsCached();
+
+        public T Single()
+        {
+            Debug.Assert((_states.Length == 1 || _states.Length == 2 && _states[0].IsRemoved) && this._states[^1].Count == 1);
+            return this._states[^1].GetItem(0);
+        }
+
+        public ImmutableArray<T> Batch()
+        {
+            var sourceBuilder = ArrayBuilder<T>.GetInstance();
+            foreach (var entry in this)
+            {
+                // we don't return removed entries to the downstream node.
+                // we're creating a new state table as part of this call, so they're no longer needed
+                if (entry.state != EntryState.Removed)
+                {
+                    sourceBuilder.Add(entry.item);
+                }
+            }
+            return sourceBuilder.ToImmutableAndFree();
+        }
+
+        public Builder ToBuilder()
+        {
+            return new Builder(this);
+        }
+
+        public sealed class Builder
+        {
+            private readonly ArrayBuilder<TableEntry> _states;
+            private readonly NodeStateTable<T> _previous;
+
+            internal Builder(NodeStateTable<T> previous)
+            {
+                _states = ArrayBuilder<TableEntry>.GetInstance();
+                _previous = previous;
+            }
+
+            public void RemoveEntries()
+            {
+                // if a new table is asked to remove entries we can just do nothing
+                // as it can't have any effect on downstream tables
+                if (_previous._states.Length > _states.Count)
+                {
+                    var previousEntries = _previous._states[_states.Count].AsRemoved();
+                    _states.Add(previousEntries);
+                }
+            }
+
+            public bool TryUseCachedEntries()
+            {
+                if (_previous._states.Length <= _states.Count)
+                {
+                    return false;
+                }
+
+                var previousEntries = _previous._states[_states.Count];
+                Debug.Assert(previousEntries.IsCached);
+
+                _states.Add(previousEntries);
+                return true;
+            }
+
+            public bool TryUseCachedEntries(out ImmutableArray<T> entries)
+            {
+                if (!TryUseCachedEntries())
+                {
+                    entries = default;
+                    return false;
+                }
+
+                entries = _states[_states.Count - 1].ToImmutableArray();
+                return true;
+            }
+
+            public bool TryModifyEntry(T value, IEqualityComparer<T> comparer)
+            {
+                if (_previous._states.Length <= _states.Count)
+                {
+                    return false;
+                }
+
+                Debug.Assert(_previous._states[_states.Count].Count == 1);
+                _states.Add(new TableEntry(value, comparer.Equals(_previous._states[0].GetItem(0), value) ? EntryState.Cached : EntryState.Modified));
+                return true;
+            }
+
+            public bool TryModifyEntries(ImmutableArray<T> outputs, IEqualityComparer<T> comparer)
+            {
+                if (_previous._states.Length <= _states.Count)
+                {
+                    return false;
+                }
+
+                // Semantics:
+                // For each item in the row, we compare with the new matching new value.
+                // - Cached when the same
+                // - Modified when different
+                // - Removed when old item position > outputs.length
+                // - Added when new item position < previousTable.length
+
+                var previousEntry = _previous._states[_states.Count];
+
+                // when both entries have no items, we can short circuit
+                if (previousEntry.Count == 0 && outputs.Length == 0)
+                {
+                    _states.Add(previousEntry);
+                    return true;
+                }
+
+                var modified = new TableEntry.Builder();
+                var sharedCount = Math.Min(previousEntry.Count, outputs.Length);
+
+                // cached or modified items
+                for (int i = 0; i < sharedCount; i++)
+                {
+                    var previous = previousEntry.GetItem(i);
+                    var replacement = outputs[i];
+
+                    var entryState = comparer.Equals(previous, replacement) ? EntryState.Cached : EntryState.Modified;
+                    modified.Add(replacement, entryState);
+                }
+
+                // removed
+                for (int i = sharedCount; i < previousEntry.Count; i++)
+                {
+                    modified.Add(previousEntry.GetItem(i), EntryState.Removed);
+                }
+
+                // added
+                for (int i = sharedCount; i < outputs.Length; i++)
+                {
+                    modified.Add(outputs[i], EntryState.Added);
+                }
+
+                _states.Add(modified.ToImmutableAndFree());
+                return true;
+            }
+
+            public void AddEntry(T value, EntryState state)
+            {
+                _states.Add(new TableEntry(value, state));
+            }
+
+            public void AddEntries(ImmutableArray<T> values, EntryState state)
+            {
+                _states.Add(new TableEntry(values, state));
+            }
+
+            public NodeStateTable<T> ToImmutableAndFree()
+            {
+                if (_states.Count == 0)
+                {
+                    _states.Free();
+                    return NodeStateTable<T>.Empty;
+                }
+
+                var hasNonCached = _states.Any(static s => !s.IsCached);
+                return new NodeStateTable<T>(_states.ToImmutableAndFree(), isCompacted: !hasNonCached);
+            }
+        }
+
+        private readonly struct TableEntry
+        {
+            private static readonly ImmutableArray<EntryState> s_allAddedEntries = ImmutableArray.Create(EntryState.Added);
+            private static readonly ImmutableArray<EntryState> s_allCachedEntries = ImmutableArray.Create(EntryState.Cached);
+            private static readonly ImmutableArray<EntryState> s_allModifiedEntries = ImmutableArray.Create(EntryState.Modified);
+            private static readonly ImmutableArray<EntryState> s_allRemovedEntries = ImmutableArray.Create(EntryState.Removed);
+
+            private readonly ImmutableArray<T> _items;
+            private readonly T? _item;
+
+            /// <summary>
+            /// Represents the corresponding state of each item in <see cref="_items"/>,
+            /// or contains a single state when <see cref="_item"/> is populated or when every state of <see cref="_items"/> has the same value.
+            /// </summary>
+            private readonly ImmutableArray<EntryState> _states;
+
+            public TableEntry(T item, EntryState state)
+                : this(item, default, GetSingleArray(state)) { }
+
+            public TableEntry(ImmutableArray<T> items, EntryState state)
+                : this(default, items, GetSingleArray(state)) { }
+
+            private TableEntry(T? item, ImmutableArray<T> items, ImmutableArray<EntryState> states)
+            {
+                Debug.Assert(!states.IsDefault);
+                Debug.Assert(states.Length == 1 || states.Distinct().Count() > 1);
+
+                this._item = item;
+                this._items = items;
+                this._states = states;
+            }
+
+            public bool IsCached => this._states == s_allCachedEntries || this._states.All(s => s == EntryState.Cached);
+
+            public bool IsRemoved => this._states == s_allRemovedEntries || this._states.All(s => s == EntryState.Removed);
+
+            public int Count => IsSingle ? 1 : _items.Length;
+
+            public T GetItem(int index)
+            {
+                Debug.Assert(!IsSingle || index == 0);
+                return IsSingle ? _item : _items[index];
+            }
+
+            public EntryState GetState(int index) => _states.Length == 1 ? _states[0] : _states[index];
+
+            public ImmutableArray<T> ToImmutableArray() => IsSingle ? ImmutableArray.Create(_item) : _items;
+
+            public TableEntry AsCached() => new(_item, _items, s_allCachedEntries);
+
+            public TableEntry AsRemoved() => new(_item, _items, s_allRemovedEntries);
+
+            [MemberNotNullWhen(true, new[] { nameof(_item) })]
+            private bool IsSingle => this._items.IsDefault;
+
+            private static ImmutableArray<EntryState> GetSingleArray(EntryState state) => state switch
+            {
+                EntryState.Added => s_allAddedEntries,
+                EntryState.Cached => s_allCachedEntries,
+                EntryState.Modified => s_allModifiedEntries,
+                EntryState.Removed => s_allRemovedEntries,
+                _ => throw ExceptionUtilities.Unreachable
+            };
+
+            public sealed class Builder
+            {
+                private readonly ArrayBuilder<T> _items = ArrayBuilder<T>.GetInstance();
+
+                private ArrayBuilder<EntryState>? _states;
+
+                private EntryState? _currentState;
+
+                public void Add(T item, EntryState state)
+                {
+                    _items.Add(item);
+                    if (!_currentState.HasValue)
+                    {
+                        _currentState = state;
+                    }
+                    else if (_states is object)
+                    {
+                        _states.Add(state);
+                    }
+                    else if (_currentState != state)
+                    {
+                        _states = ArrayBuilder<EntryState>.GetInstance(_items.Count - 1, _currentState.Value);
+                        _states.Add(state);
+                    }
+                }
+
+                public TableEntry ToImmutableAndFree()
+                {
+                    Debug.Assert(_currentState.HasValue, "Created a builder with no values?");
+                    return new TableEntry(item: default, _items.ToImmutableAndFree(), _states?.ToImmutableAndFree() ?? GetSingleArray(_currentState.Value));
+                }
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/PostInitOutputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/PostInitOutputNode.cs
new file mode 100644
index 0000000000000..cd55a2de97631
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/PostInitOutputNode.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class PostInitOutputNode : IIncrementalGeneratorOutputNode
+    {
+        private readonly Action<IncrementalGeneratorPostInitializationContext> _callback;
+
+        public PostInitOutputNode(Action<IncrementalGeneratorPostInitializationContext> callback)
+        {
+            _callback = callback;
+        }
+
+        public IncrementalGeneratorOutputKind Kind => IncrementalGeneratorOutputKind.PostInit;
+
+        public void AppendOutputs(IncrementalExecutionContext context, CancellationToken cancellationToken)
+        {
+            _callback(new IncrementalGeneratorPostInitializationContext(context.Sources, cancellationToken));
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SharedInputNodes.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SharedInputNodes.cs
new file mode 100644
index 0000000000000..77d1346907130
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SharedInputNodes.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Diagnostics;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// Holds input nodes that are shared between generators and always exist
+    /// </summary>
+    internal static class SharedInputNodes
+    {
+        public static readonly InputNode<Compilation> Compilation = new InputNode<Compilation>(b => ImmutableArray.Create(b.Compilation));
+
+        public static readonly InputNode<ParseOptions> ParseOptions = new InputNode<ParseOptions>(b => ImmutableArray.Create(b.DriverState.ParseOptions));
+
+        public static readonly InputNode<AdditionalText> AdditionalTexts = new InputNode<AdditionalText>(b => b.DriverState.AdditionalTexts);
+
+        public static readonly InputNode<SyntaxTree> SyntaxTrees = new InputNode<SyntaxTree>(b => b.Compilation.SyntaxTrees.ToImmutableArray());
+
+        public static readonly InputNode<AnalyzerConfigOptionsProvider> AnalyzerConfigOptions = new InputNode<AnalyzerConfigOptionsProvider>(b => ImmutableArray.Create(b.DriverState.OptionsProvider));
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs
new file mode 100644
index 0000000000000..48ab3d34bdd7b
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs
@@ -0,0 +1,104 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Threading;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+using TOutput = System.ValueTuple<System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.GeneratedSourceText>, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic>>;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class SourceOutputNode<TInput> : IIncrementalGeneratorOutputNode, IIncrementalGeneratorNode<TOutput>
+    {
+        private readonly IIncrementalGeneratorNode<TInput> _source;
+
+        private readonly Action<SourceProductionContext, TInput> _action;
+
+        public SourceOutputNode(IIncrementalGeneratorNode<TInput> source, Action<SourceProductionContext, TInput> action)
+        {
+            _source = source;
+            _action = action;
+        }
+
+        public IncrementalGeneratorOutputKind Kind => IncrementalGeneratorOutputKind.Source;
+
+        public NodeStateTable<TOutput> UpdateStateTable(DriverStateTable.Builder graphState, NodeStateTable<TOutput> previousTable, CancellationToken cancellationToken)
+        {
+            var sourceTable = graphState.GetLatestStateTableForNode(_source);
+            if (sourceTable.IsCached)
+            {
+                return previousTable;
+            }
+
+            var nodeTable = previousTable.ToBuilder();
+            foreach (var entry in sourceTable)
+            {
+                if (entry.state == EntryState.Removed)
+                {
+                    nodeTable.RemoveEntries();
+                }
+                else if (entry.state != EntryState.Cached || !nodeTable.TryUseCachedEntries())
+                {
+                    // we don't currently handle modified any differently than added at the output
+                    // we just run the action and mark the new source as added. In theory we could compare
+                    // the diagnostics and sources produced and compare them, to see if they are any different 
+                    // than before.
+
+                    var sourcesBuilder = ArrayBuilder<GeneratedSourceText>.GetInstance();
+                    var diagnostics = DiagnosticBag.GetInstance();
+
+                    SourceProductionContext context = new SourceProductionContext(sourcesBuilder, diagnostics, cancellationToken);
+                    try
+                    {
+                        _action(context, entry.item);
+                        nodeTable.AddEntry((sourcesBuilder.ToImmutable(), diagnostics.ToReadOnly()), EntryState.Added);
+                    }
+                    finally
+                    {
+                        sourcesBuilder.Free();
+                        diagnostics.Free();
+                    }
+
+                }
+            }
+
+            return nodeTable.ToImmutableAndFree();
+        }
+
+        IIncrementalGeneratorNode<TOutput> IIncrementalGeneratorNode<TOutput>.WithComparer(IEqualityComparer<TOutput> comparer) => throw ExceptionUtilities.Unreachable;
+
+        void IIncrementalGeneratorNode<TOutput>.RegisterOutput(IIncrementalGeneratorOutputNode output) => throw ExceptionUtilities.Unreachable;
+
+        public void AppendOutputs(IncrementalExecutionContext context, CancellationToken cancellationToken)
+        {
+            // get our own state table
+            Debug.Assert(context.TableBuilder is object);
+            var table = context.TableBuilder.GetLatestStateTableForNode(this);
+
+            // add each non-removed entry to the context
+            foreach (var ((sources, diagnostics), state) in table)
+            {
+                if (state != EntryState.Removed)
+                {
+                    foreach (var text in sources)
+                    {
+                        try
+                        {
+                            context.Sources.Add(text.HintName, text.Text);
+                        }
+                        catch (ArgumentException e)
+                        {
+                            throw new UserFunctionException(e);
+                        }
+                    }
+                    context.Diagnostics.AddRange(diagnostics);
+                }
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxInputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxInputNode.cs
new file mode 100644
index 0000000000000..914674882a436
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxInputNode.cs
@@ -0,0 +1,98 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class SyntaxInputNode<T> : IIncrementalGeneratorNode<T>, ISyntaxInputNode
+    {
+        private readonly Func<GeneratorSyntaxContext, CancellationToken, T> _transformFunc;
+        private readonly Action<ISyntaxInputNode, IIncrementalGeneratorOutputNode> _registerOutputAndNode;
+        private readonly Func<SyntaxNode, CancellationToken, bool> _filterFunc;
+        private readonly IEqualityComparer<T> _comparer;
+        private readonly object _filterKey = new object();
+
+        internal SyntaxInputNode(Func<SyntaxNode, CancellationToken, bool> filterFunc, Func<GeneratorSyntaxContext, CancellationToken, T> transformFunc, Action<ISyntaxInputNode, IIncrementalGeneratorOutputNode> registerOutputAndNode, IEqualityComparer<T>? comparer = null)
+        {
+            _transformFunc = transformFunc;
+            _registerOutputAndNode = registerOutputAndNode;
+            _filterFunc = filterFunc;
+            _comparer = comparer ?? EqualityComparer<T>.Default;
+        }
+
+        public NodeStateTable<T> UpdateStateTable(DriverStateTable.Builder graphState, NodeStateTable<T> previousTable, CancellationToken cancellationToken)
+        {
+            return (NodeStateTable<T>)graphState.GetSyntaxInputTable(this);
+        }
+
+        public IIncrementalGeneratorNode<T> WithComparer(IEqualityComparer<T> comparer) => new SyntaxInputNode<T>(_filterFunc, _transformFunc, _registerOutputAndNode, comparer);
+
+        public ISyntaxInputBuilder GetBuilder(DriverStateTable table) => new Builder(this, table);
+
+        public void RegisterOutput(IIncrementalGeneratorOutputNode output) => _registerOutputAndNode(this, output);
+
+        private sealed class Builder : ISyntaxInputBuilder
+        {
+            private readonly SyntaxInputNode<T> _owner;
+
+            private readonly NodeStateTable<SyntaxNode>.Builder _filterTable;
+
+            private readonly NodeStateTable<T>.Builder _transformTable;
+
+            public Builder(SyntaxInputNode<T> owner, DriverStateTable table)
+            {
+                _owner = owner;
+                _filterTable = table.GetStateTableOrEmpty<SyntaxNode>(_owner._filterKey).ToBuilder();
+                _transformTable = table.GetStateTableOrEmpty<T>(_owner).ToBuilder();
+            }
+
+            public ISyntaxInputNode SyntaxInputNode { get => _owner; }
+
+            public void SaveStateAndFree(ImmutableDictionary<object, IStateTable>.Builder tables)
+            {
+                tables[_owner._filterKey] = _filterTable.ToImmutableAndFree();
+                tables[_owner] = _transformTable.ToImmutableAndFree();
+            }
+
+            public void VisitTree(SyntaxNode root, EntryState state, SemanticModel? model, CancellationToken cancellationToken)
+            {
+                if (state == EntryState.Removed)
+                {
+                    // mark both syntax *and* transform nodes removed
+                    _filterTable.RemoveEntries();
+                    _transformTable.RemoveEntries();
+                }
+                else
+                {
+                    Debug.Assert(model is object);
+
+                    // get the syntax nodes from cache, or a syntax walk using the filter
+                    ImmutableArray<SyntaxNode> nodes;
+                    if (state != EntryState.Cached || !_filterTable.TryUseCachedEntries(out nodes))
+                    {
+                        nodes = IncrementalGeneratorSyntaxWalker.GetFilteredNodes(root, _owner._filterFunc, cancellationToken);
+                        _filterTable.AddEntries(nodes, EntryState.Added);
+                    }
+
+                    // now, using the obtained syntax nodes, run the transform
+                    foreach (var node in nodes)
+                    {
+                        var value = new GeneratorSyntaxContext(node, model);
+                        var transformed = ImmutableArray.Create(_owner._transformFunc(value, cancellationToken));
+
+                        if (state == EntryState.Added || !_transformTable.TryModifyEntries(transformed, _owner._comparer))
+                        {
+                            _transformTable.AddEntries(transformed, EntryState.Added);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxReceiverInputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxReceiverInputNode.cs
new file mode 100644
index 0000000000000..d6b213982fc9e
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxReceiverInputNode.cs
@@ -0,0 +1,91 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Threading;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class SyntaxReceiverInputNode : ISyntaxInputNode, IIncrementalGeneratorNode<ISyntaxContextReceiver?>
+    {
+        private readonly SyntaxContextReceiverCreator _receiverCreator;
+        private readonly Action<IIncrementalGeneratorOutputNode> _registerOutput;
+
+        public SyntaxReceiverInputNode(SyntaxContextReceiverCreator receiverCreator, Action<IIncrementalGeneratorOutputNode> registerOutput)
+        {
+            _receiverCreator = receiverCreator;
+            _registerOutput = registerOutput;
+        }
+
+        public NodeStateTable<ISyntaxContextReceiver?> UpdateStateTable(DriverStateTable.Builder graphState, NodeStateTable<ISyntaxContextReceiver?> previousTable, CancellationToken cancellationToken)
+        {
+            return (NodeStateTable<ISyntaxContextReceiver?>)graphState.GetSyntaxInputTable(this);
+        }
+
+        public IIncrementalGeneratorNode<ISyntaxContextReceiver?> WithComparer(IEqualityComparer<ISyntaxContextReceiver?> comparer)
+        {
+            // we don't expose this node to end users
+            throw ExceptionUtilities.Unreachable;
+        }
+
+        public ISyntaxInputBuilder GetBuilder(DriverStateTable table) => new Builder(this, table);
+
+        public void RegisterOutput(IIncrementalGeneratorOutputNode output) => _registerOutput(output);
+
+        private sealed class Builder : ISyntaxInputBuilder
+        {
+            private readonly SyntaxReceiverInputNode _owner;
+            private readonly NodeStateTable<ISyntaxContextReceiver?>.Builder _nodeStateTable;
+            private readonly ISyntaxContextReceiver? _receiver;
+            private readonly GeneratorSyntaxWalker? _walker;
+
+            public Builder(SyntaxReceiverInputNode owner, DriverStateTable driverStateTable)
+            {
+                _owner = owner;
+                _nodeStateTable = driverStateTable.GetStateTableOrEmpty<ISyntaxContextReceiver?>(_owner).ToBuilder();
+                try
+                {
+                    _receiver = owner._receiverCreator();
+                }
+                catch (Exception e)
+                {
+                    throw new UserFunctionException(e);
+                }
+
+                if (_receiver is object)
+                {
+                    _walker = new GeneratorSyntaxWalker(_receiver);
+                }
+            }
+
+            public ISyntaxInputNode SyntaxInputNode { get => _owner; }
+
+            public void SaveStateAndFree(ImmutableDictionary<object, IStateTable>.Builder tables)
+            {
+                _nodeStateTable.AddEntry(_receiver, EntryState.Modified);
+                tables[_owner] = _nodeStateTable.ToImmutableAndFree();
+            }
+
+            public void VisitTree(SyntaxNode root, EntryState state, SemanticModel? model, CancellationToken cancellationToken)
+            {
+                if (_walker is object && state != EntryState.Removed)
+                {
+                    Debug.Assert(model is object);
+                    try
+                    {
+                        _walker.VisitWithModel(model, root);
+                    }
+                    catch (Exception e)
+                    {
+                        throw new UserFunctionException(e);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxValueProvider.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxValueProvider.cs
new file mode 100644
index 0000000000000..f545caef16e4f
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxValueProvider.cs
@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics;
+using System.Threading;
+using Microsoft.CodeAnalysis.PooledObjects;
+
+namespace Microsoft.CodeAnalysis
+{
+    /// <summary>
+    /// Allows a user to create Syntax based input nodes for incremental generation
+    /// </summary>
+    public readonly struct SyntaxValueProvider
+    {
+        private readonly ArrayBuilder<ISyntaxInputNode> _inputNodes;
+        private readonly Action<IIncrementalGeneratorOutputNode> _registerOutput;
+
+        internal SyntaxValueProvider(ArrayBuilder<ISyntaxInputNode> inputNodes, Action<IIncrementalGeneratorOutputNode> registerOutput)
+        {
+            _inputNodes = inputNodes;
+            _registerOutput = registerOutput;
+        }
+
+        /// <summary>
+        /// Creates an <see cref="IncrementalValueProvider{T}"/> that can provide a transform over <see cref="SyntaxNode"/>s
+        /// </summary>
+        /// <typeparam name="T">The type of the value the syntax node is transformed into</typeparam>
+        /// <param name="predicate">A function that determines if the given <see cref="SyntaxNode"/> should be transformed</param>
+        /// <param name="transform">A function that performs the transform, when <paramref name="predicate"/>returns <c>true</c> for a given node</param>
+        /// <returns>An <see cref="IncrementalValueProvider{T}"/> that provides the results of the transformation</returns>
+        public IncrementalValuesProvider<T> CreateSyntaxProvider<T>(Func<SyntaxNode, CancellationToken, bool> predicate, Func<GeneratorSyntaxContext, CancellationToken, T> transform)
+        {
+            // registration of the input is deferred until we know the node is used
+            return new IncrementalValuesProvider<T>(new SyntaxInputNode<T>(predicate.WrapUserFunction(), transform.WrapUserFunction(), RegisterOutputAndDeferredInput));
+        }
+
+        /// <summary>
+        /// Creates a syntax receiver input node. Only used for back compat in <see cref="SourceGeneratorAdaptor"/>
+        /// </summary>
+        internal IncrementalValueProvider<ISyntaxContextReceiver?> CreateSyntaxReceiverProvider(SyntaxContextReceiverCreator creator)
+        {
+            var node = new SyntaxReceiverInputNode(creator, _registerOutput);
+            _inputNodes.Add(node);
+            return new IncrementalValueProvider<ISyntaxContextReceiver?>(node);
+        }
+
+        private void RegisterOutputAndDeferredInput(ISyntaxInputNode node, IIncrementalGeneratorOutputNode output)
+        {
+            _registerOutput(output);
+            if (!_inputNodes.Contains(node))
+            {
+                _inputNodes.Add(node);
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs
new file mode 100644
index 0000000000000..8804cfad56596
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs
@@ -0,0 +1,71 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class TransformNode<TInput, TOutput> : IIncrementalGeneratorNode<TOutput>
+    {
+        private readonly Func<TInput, CancellationToken, ImmutableArray<TOutput>> _func;
+        private readonly IEqualityComparer<TOutput> _comparer;
+        private readonly IIncrementalGeneratorNode<TInput> _sourceNode;
+
+        public TransformNode(IIncrementalGeneratorNode<TInput> sourceNode, Func<TInput, CancellationToken, TOutput> userFunc, IEqualityComparer<TOutput>? comparer = null)
+            : this(sourceNode, userFunc: (i, token) => ImmutableArray.Create(userFunc(i, token)), comparer)
+        {
+        }
+
+        public TransformNode(IIncrementalGeneratorNode<TInput> sourceNode, Func<TInput, CancellationToken, ImmutableArray<TOutput>> userFunc, IEqualityComparer<TOutput>? comparer = null)
+        {
+            _sourceNode = sourceNode;
+            _func = userFunc;
+            _comparer = comparer ?? EqualityComparer<TOutput>.Default;
+        }
+
+        public IIncrementalGeneratorNode<TOutput> WithComparer(IEqualityComparer<TOutput> comparer) => new TransformNode<TInput, TOutput>(_sourceNode, _func, comparer);
+
+        public NodeStateTable<TOutput> UpdateStateTable(DriverStateTable.Builder builder, NodeStateTable<TOutput> previousTable, CancellationToken cancellationToken)
+        {
+            // grab the source inputs
+            var sourceTable = builder.GetLatestStateTableForNode(_sourceNode);
+            if (sourceTable.IsCached)
+            {
+                return previousTable;
+            }
+
+            // Semantics of a transform:
+            // Element-wise comparison of upstream table
+            // - Cached or Removed: no transform, just use previous values
+            // - Added: perform transform and add
+            // - Modified: perform transform and do element wise comparison with previous results
+
+            var newTable = previousTable.ToBuilder();
+
+            foreach (var entry in sourceTable)
+            {
+                if (entry.state == EntryState.Removed)
+                {
+                    newTable.RemoveEntries();
+                }
+                else if (entry.state != EntryState.Cached || !newTable.TryUseCachedEntries())
+                {
+                    // generate the new entries
+                    var newOutputs = _func(entry.item, cancellationToken);
+
+                    if (entry.state != EntryState.Modified || !newTable.TryModifyEntries(newOutputs, _comparer))
+                    {
+                        newTable.AddEntries(newOutputs, EntryState.Added);
+                    }
+                }
+            }
+            return newTable.ToImmutableAndFree();
+        }
+
+        public void RegisterOutput(IIncrementalGeneratorOutputNode output) => _sourceNode.RegisterOutput(output);
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/ValueSourceExtensions.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/ValueSourceExtensions.cs
new file mode 100644
index 0000000000000..6c91718e8fa54
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/ValueSourceExtensions.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Text;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    public static class IncrementalValueProviderExtensions
+    {
+        // 1 => 1 transform 
+        public static IncrementalValueProvider<TResult> Select<TSource, TResult>(this IncrementalValueProvider<TSource> source, Func<TSource, CancellationToken, TResult> selector) => new IncrementalValueProvider<TResult>(new TransformNode<TSource, TResult>(source.Node, selector.WrapUserFunction()));
+
+        public static IncrementalValuesProvider<TResult> Select<TSource, TResult>(this IncrementalValuesProvider<TSource> source, Func<TSource, CancellationToken, TResult> selector) => new IncrementalValuesProvider<TResult>(new TransformNode<TSource, TResult>(source.Node, selector.WrapUserFunction()));
+
+        // 1 => many (or none) transform
+        public static IncrementalValuesProvider<TResult> SelectMany<TSource, TResult>(this IncrementalValueProvider<TSource> source, Func<TSource, CancellationToken, ImmutableArray<TResult>> selector) => new IncrementalValuesProvider<TResult>(new TransformNode<TSource, TResult>(source.Node, selector.WrapUserFunction()));
+
+        public static IncrementalValuesProvider<TResult> SelectMany<TSource, TResult>(this IncrementalValueProvider<TSource> source, Func<TSource, CancellationToken, IEnumerable<TResult>> selector) => new IncrementalValuesProvider<TResult>(new TransformNode<TSource, TResult>(source.Node, selector.WrapUserFunctionAsImmutableArray()));
+
+        public static IncrementalValuesProvider<TResult> SelectMany<TSource, TResult>(this IncrementalValuesProvider<TSource> source, Func<TSource, CancellationToken, ImmutableArray<TResult>> selector) => new IncrementalValuesProvider<TResult>(new TransformNode<TSource, TResult>(source.Node, selector.WrapUserFunction()));
+
+        public static IncrementalValuesProvider<TResult> SelectMany<TSource, TResult>(this IncrementalValuesProvider<TSource> source, Func<TSource, CancellationToken, IEnumerable<TResult>> selector) => new IncrementalValuesProvider<TResult>(new TransformNode<TSource, TResult>(source.Node, selector.WrapUserFunctionAsImmutableArray()));
+
+        public static IncrementalValueProvider<ImmutableArray<TSource>> Collect<TSource>(this IncrementalValuesProvider<TSource> source) => new IncrementalValueProvider<ImmutableArray<TSource>>(new BatchNode<TSource>(source.Node));
+
+        public static IncrementalValuesProvider<(TLeft Left, TRight Right)> Combine<TLeft, TRight>(this IncrementalValuesProvider<TLeft> provider1, IncrementalValueProvider<TRight> provider2) => new IncrementalValuesProvider<(TLeft, TRight)>(new CombineNode<TLeft, TRight>(provider1.Node, provider2.Node));
+
+        public static IncrementalValueProvider<(TLeft Left, TRight Right)> Combine<TLeft, TRight>(this IncrementalValueProvider<TLeft> provider1, IncrementalValueProvider<TRight> provider2) => new IncrementalValueProvider<(TLeft, TRight)>(new CombineNode<TLeft, TRight>(provider1.Node, provider2.Node));
+
+        // helper for filtering
+        public static IncrementalValuesProvider<TSource> Where<TSource>(this IncrementalValuesProvider<TSource> source, Func<TSource, bool> predicate) => source.SelectMany((item, _) => predicate(item) ? ImmutableArray.Create(item) : ImmutableArray<TSource>.Empty);
+
+        // custom comparer for given node
+        public static IncrementalValueProvider<TSource> WithComparer<TSource>(this IncrementalValueProvider<TSource> source, IEqualityComparer<TSource> comparer) => new IncrementalValueProvider<TSource>(source.Node.WithComparer(comparer));
+
+        public static IncrementalValuesProvider<TSource> WithComparer<TSource>(this IncrementalValuesProvider<TSource> source, IEqualityComparer<TSource> comparer) => new IncrementalValuesProvider<TSource>(source.Node.WithComparer(comparer));
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/PendingEdit.cs b/src/Compilers/Core/Portable/SourceGeneration/PendingEdit.cs
deleted file mode 100644
index da345876101c2..0000000000000
--- a/src/Compilers/Core/Portable/SourceGeneration/PendingEdit.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-namespace Microsoft.CodeAnalysis
-{
-    internal delegate bool EditCallback<T>(GeneratorEditContext context, T edit) where T : PendingEdit;
-
-    internal abstract class PendingEdit
-    {
-        internal abstract GeneratorDriverState Commit(GeneratorDriverState state);
-
-        internal abstract bool AcceptedBy(GeneratorInfo info);
-
-        internal abstract bool TryApply(GeneratorInfo info, GeneratorEditContext context);
-    }
-
-    internal abstract class AdditionalFileEdit : PendingEdit
-    {
-    }
-
-    internal sealed class AdditionalFileAddedEdit : AdditionalFileEdit
-    {
-        public AdditionalFileAddedEdit(AdditionalText addedText)
-        {
-            AddedText = addedText;
-        }
-
-        public AdditionalText AddedText { get; }
-
-        internal override GeneratorDriverState Commit(GeneratorDriverState state) => state.With(additionalTexts: state.AdditionalTexts.Add(this.AddedText));
-
-        internal override bool AcceptedBy(GeneratorInfo info) => info.EditCallback is object;
-
-        internal override bool TryApply(GeneratorInfo info, GeneratorEditContext context) => info.EditCallback!.Invoke(context, this);
-    }
-}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs b/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs
new file mode 100644
index 0000000000000..87b59cc4e6e40
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs
@@ -0,0 +1,75 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Text;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class UserFunctionException : Exception
+    {
+        public new Exception InnerException => base.InnerException!;
+
+        public UserFunctionException(Exception innerException)
+            : base("User provided code threw an exception", innerException)
+        {
+        }
+    }
+
+    internal static class UserFunctionExtensions
+    {
+        internal static Func<TInput, CancellationToken, TOutput> WrapUserFunction<TInput, TOutput>(this Func<TInput, CancellationToken, TOutput> userFunction)
+        {
+            return (input, token) =>
+            {
+                try
+                {
+                    return userFunction(input, token);
+                }
+                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, token))
+                {
+                    throw new UserFunctionException(e);
+                }
+            };
+        }
+
+        internal static Func<TInput, CancellationToken, ImmutableArray<TOutput>> WrapUserFunctionAsImmutableArray<TInput, TOutput>(this Func<TInput, CancellationToken, IEnumerable<TOutput>> userFunction)
+        {
+            return (input, token) => userFunction.WrapUserFunction()(input, token).ToImmutableArray();
+        }
+
+        internal static Action<TInput> WrapUserAction<TInput>(this Action<TInput> userAction)
+        {
+            return input =>
+            {
+                try
+                {
+                    userAction(input);
+                }
+                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+                {
+                    throw new UserFunctionException(e);
+                }
+            };
+        }
+
+        internal static Action<TInput1, TInput2> WrapUserAction<TInput1, TInput2>(this Action<TInput1, TInput2> userAction)
+        {
+            return (input1, input2) =>
+            {
+                try
+                {
+                    userAction(input1, input2);
+                }
+                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+                {
+                    throw new UserFunctionException(e);
+                }
+            };
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/Symbols/Attributes/CommonMethodWellKnownAttributeData.cs b/src/Compilers/Core/Portable/Symbols/Attributes/CommonMethodWellKnownAttributeData.cs
index d4fb46418911b..a4c0da5526f9c 100644
--- a/src/Compilers/Core/Portable/Symbols/Attributes/CommonMethodWellKnownAttributeData.cs
+++ b/src/Compilers/Core/Portable/Symbols/Attributes/CommonMethodWellKnownAttributeData.cs
@@ -2,13 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Diagnostics;
 using System.Reflection;
-using System.Runtime.CompilerServices;
-using Microsoft.CodeAnalysis.Text;
-using Cci = Microsoft.Cci;
 
 namespace Microsoft.CodeAnalysis
 {
@@ -36,7 +31,7 @@ public CommonMethodWellKnownAttributeData()
         private readonly bool _preserveSigFirstWriteWins;
 
         // data from DllImportAttribute
-        private DllImportData _platformInvokeInfo;
+        private DllImportData? _platformInvokeInfo;
         private bool _dllImportPreserveSig;
         private int _dllImportIndex;               // -1 .. not specified
 
@@ -67,7 +62,7 @@ public void SetMethodImplementation(int attributeIndex, MethodImplAttributes att
         }
 
         // used by DllImportAttribute
-        public void SetDllImport(int attributeIndex, string moduleName, string entryPointName, MethodImportAttributes flags, bool preserveSig)
+        public void SetDllImport(int attributeIndex, string? moduleName, string? entryPointName, MethodImportAttributes flags, bool preserveSig)
         {
             VerifySealed(expected: false);
             Debug.Assert(attributeIndex >= 0);
@@ -77,7 +72,7 @@ public void SetDllImport(int attributeIndex, string moduleName, string entryPoin
             SetDataStored();
         }
 
-        public DllImportData DllImportPlatformInvokeData
+        public DllImportData? DllImportPlatformInvokeData
         {
             get
             {
@@ -181,7 +176,7 @@ public bool HasSuppressUnmanagedCodeSecurityAttribute
         #endregion
 
         #region Security Attributes
-        private SecurityWellKnownAttributeData _lazySecurityAttributeData;
+        private SecurityWellKnownAttributeData? _lazySecurityAttributeData;
 
         SecurityWellKnownAttributeData ISecurityAttributeTarget.GetOrCreateData()
         {
@@ -208,7 +203,7 @@ internal bool HasDeclarativeSecurity
         /// <summary>
         /// Returns data decoded from security attributes or null if there are no security attributes.
         /// </summary>
-        public SecurityWellKnownAttributeData SecurityInformation
+        public SecurityWellKnownAttributeData? SecurityInformation
         {
             get
             {
diff --git a/src/Compilers/Core/Portable/Syntax/LineDirectiveMap.LineMappingEntry.cs b/src/Compilers/Core/Portable/Syntax/LineDirectiveMap.LineMappingEntry.cs
index eff85cb1d1b61..111fe5aeca5b4 100644
--- a/src/Compilers/Core/Portable/Syntax/LineDirectiveMap.LineMappingEntry.cs
+++ b/src/Compilers/Core/Portable/Syntax/LineDirectiveMap.LineMappingEntry.cs
@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis
 {
@@ -29,6 +31,11 @@ public enum PositionState : byte
             /// </summary>
             Remapped,
 
+            /// <summary>
+            /// Used in C# for spans inside of <c>#line (startLine, startChar) - (endLine, endChar) charOffset</c> directive
+            /// </summary>
+            RemappedSpan,
+
             /// <summary>
             /// Used in VB for spans inside of a <c>#ExternalSource</c> directive that followed an unknown span
             /// </summary>
@@ -56,6 +63,12 @@ public enum PositionState : byte
             // 0-based line it maps to.
             public readonly int MappedLine;
 
+            // 0-based mapped span from enhanced #line directive.
+            public readonly LinePositionSpan MappedSpan;
+
+            // optional 0-based character offset from enhanced #line directive.
+            public readonly int? UnmappedCharacterOffset;
+
             // raw value from #line or #ExternalDirective, may be null
             public readonly string? MappedPathOpt;
 
@@ -66,6 +79,8 @@ public LineMappingEntry(int unmappedLine)
             {
                 this.UnmappedLine = unmappedLine;
                 this.MappedLine = unmappedLine;
+                this.MappedSpan = default;
+                this.UnmappedCharacterOffset = null;
                 this.MappedPathOpt = null;
                 this.State = PositionState.Unmapped;
             }
@@ -76,12 +91,30 @@ public LineMappingEntry(
                 string? mappedPathOpt,
                 PositionState state)
             {
+                Debug.Assert(state != PositionState.RemappedSpan);
+
                 this.UnmappedLine = unmappedLine;
                 this.MappedLine = mappedLine;
+                this.MappedSpan = default;
+                this.UnmappedCharacterOffset = null;
                 this.MappedPathOpt = mappedPathOpt;
                 this.State = state;
             }
 
+            public LineMappingEntry(
+                int unmappedLine,
+                LinePositionSpan mappedSpan,
+                int? unmappedCharacterOffset,
+                string? mappedPathOpt)
+            {
+                this.UnmappedLine = unmappedLine;
+                this.MappedLine = -1;
+                this.MappedSpan = mappedSpan;
+                this.UnmappedCharacterOffset = unmappedCharacterOffset;
+                this.MappedPathOpt = mappedPathOpt;
+                this.State = PositionState.RemappedSpan;
+            }
+
             public int CompareTo(LineMappingEntry other)
                 => UnmappedLine.CompareTo(other.UnmappedLine);
 
diff --git a/src/Compilers/Core/Portable/Syntax/LineDirectiveMap.cs b/src/Compilers/Core/Portable/Syntax/LineDirectiveMap.cs
index 3ad2f7bdbc6cc..ed0ed6793fd1d 100644
--- a/src/Compilers/Core/Portable/Syntax/LineDirectiveMap.cs
+++ b/src/Compilers/Core/Portable/Syntax/LineDirectiveMap.cs
@@ -55,18 +55,49 @@ public FileLinePositionSpan TranslateSpan(SourceText sourceText, string treeFile
             return TranslateSpan(entry, treeFilePath, unmappedStartPos, unmappedEndPos);
         }
 
-        protected FileLinePositionSpan TranslateSpan(LineMappingEntry entry, string treeFilePath, LinePosition unmappedStartPos, LinePosition unmappedEndPos)
+        protected FileLinePositionSpan TranslateSpan(in LineMappingEntry entry, string treeFilePath, LinePosition unmappedStartPos, LinePosition unmappedEndPos)
         {
             string path = entry.MappedPathOpt ?? treeFilePath;
-            int mappedStartLine = unmappedStartPos.Line - entry.UnmappedLine + entry.MappedLine;
-            int mappedEndLine = unmappedEndPos.Line - entry.UnmappedLine + entry.MappedLine;
-
-            return new FileLinePositionSpan(
-                path,
-                new LinePositionSpan(
-                    (mappedStartLine == -1) ? new LinePosition(unmappedStartPos.Character) : new LinePosition(mappedStartLine, unmappedStartPos.Character),
-                    (mappedEndLine == -1) ? new LinePosition(unmappedEndPos.Character) : new LinePosition(mappedEndLine, unmappedEndPos.Character)),
-                hasMappedPath: entry.MappedPathOpt != null);
+            var span = entry.State == PositionState.RemappedSpan ?
+                TranslateEnhancedLineDirectiveSpan(entry, unmappedStartPos, unmappedEndPos) :
+                TranslateLineDirectiveSpan(entry, unmappedStartPos, unmappedEndPos);
+            return new FileLinePositionSpan(path, span, hasMappedPath: entry.MappedPathOpt != null);
+        }
+
+        private static LinePositionSpan TranslateLineDirectiveSpan(in LineMappingEntry entry, LinePosition unmappedStartPos, LinePosition unmappedEndPos)
+        {
+            return new LinePositionSpan(translatePosition(entry, unmappedStartPos), translatePosition(entry, unmappedEndPos));
+
+            static LinePosition translatePosition(in LineMappingEntry entry, LinePosition unmapped)
+            {
+                int mappedLine = unmapped.Line - entry.UnmappedLine + entry.MappedLine;
+                return (mappedLine == -1) ? new LinePosition(unmapped.Character) : new LinePosition(mappedLine, unmapped.Character);
+            }
+        }
+
+        private static LinePositionSpan TranslateEnhancedLineDirectiveSpan(in LineMappingEntry entry, LinePosition unmappedStartPos, LinePosition unmappedEndPos)
+        {
+            // A span starting on the first line, at or before 'UnmappedCharacterOffset' is
+            // mapped to the entire 'MappedSpan', regardless of the size of the unmapped span,
+            // even if the unmapped span ends before 'UnmappedCharacterOffset'.
+            if (unmappedStartPos.Line == entry.UnmappedLine &&
+                unmappedStartPos.Character <= entry.UnmappedCharacterOffset.GetValueOrDefault())
+            {
+                return entry.MappedSpan;
+            }
+
+            // A span starting on the first line after 'UnmappedCharacterOffset', or starting on
+            // a subseqent line, is mapped to a span of corresponding size.
+            return new LinePositionSpan(translatePosition(entry, unmappedStartPos), translatePosition(entry, unmappedEndPos));
+
+            static LinePosition translatePosition(in LineMappingEntry entry, LinePosition unmapped)
+            {
+                return new LinePosition(
+                    unmapped.Line - entry.UnmappedLine + entry.MappedSpan.Start.Line,
+                    unmapped.Line == entry.UnmappedLine ?
+                        entry.MappedSpan.Start.Character + unmapped.Character - entry.UnmappedCharacterOffset.GetValueOrDefault() :
+                        unmapped.Character);
+            }
         }
 
         /// <summary>
@@ -151,26 +182,6 @@ current.State is PositionState.Unmapped or PositionState.Unknown &&
                 current.MappedLine == 0 &&
                 current.MappedPathOpt == null);
 
-            LineMapping CreateCurrentEntryMapping(in LineMappingEntry entry, int unmappedEndLine, int lineLength, int currentIndex)
-            {
-                var unmapped = new LinePositionSpan(
-                    new LinePosition(entry.UnmappedLine, character: 0),
-                    new LinePosition(unmappedEndLine, lineLength));
-
-                var isHidden =
-                    entry.State == PositionState.Hidden ||
-                    entry.State == PositionState.Unknown && GetUnknownStateVisibility(currentIndex) == LineVisibility.Hidden;
-
-                var mapped = isHidden ? default : new FileLinePositionSpan(
-                    entry.MappedPathOpt ?? string.Empty,
-                    new LinePositionSpan(
-                        new LinePosition(entry.MappedLine, character: 0),
-                        new LinePosition(entry.MappedLine + unmappedEndLine - entry.UnmappedLine, lineLength)),
-                    hasMappedPath: entry.MappedPathOpt != null);
-
-                return new LineMapping(unmapped, mapped);
-            }
-
             for (int i = 1; i < Entries.Length; i++)
             {
                 var next = Entries[i];
@@ -197,7 +208,7 @@ LineMapping CreateCurrentEntryMapping(in LineMappingEntry entry, int unmappedEnd
                     var endLine = lines[unmappedEndLine];
                     int lineLength = endLine.EndIncludingLineBreak - endLine.Start;
 
-                    yield return CreateCurrentEntryMapping(current, unmappedEndLine, lineLength, currentIndex: i - 1);
+                    yield return CreateLineMapping(current, unmappedEndLine, lineLength, currentIndex: i - 1);
                 }
 
                 current = next;
@@ -218,8 +229,38 @@ LineMapping CreateCurrentEntryMapping(in LineMappingEntry entry, int unmappedEnd
                 int lineLength = lastLine.EndIncludingLineBreak - lastLine.Start;
                 int unmappedEndLine = lastLine.LineNumber;
 
-                yield return CreateCurrentEntryMapping(current, unmappedEndLine, lineLength, currentIndex: Entries.Length - 1);
+                yield return CreateLineMapping(current, unmappedEndLine, lineLength, currentIndex: Entries.Length - 1);
+            }
+        }
+
+        private LineMapping CreateLineMapping(in LineMappingEntry entry, int unmappedEndLine, int lineLength, int currentIndex)
+        {
+            var unmapped = new LinePositionSpan(
+                new LinePosition(entry.UnmappedLine, character: 0),
+                new LinePosition(unmappedEndLine, lineLength));
+
+            if (entry.State == PositionState.Hidden ||
+                entry.State == PositionState.Unknown && GetUnknownStateVisibility(currentIndex) == LineVisibility.Hidden)
+            {
+                return new LineMapping(unmapped, characterOffset: null, mappedSpan: default);
             }
+
+            string path = entry.MappedPathOpt ?? string.Empty;
+            bool hasMappedPath = entry.MappedPathOpt != null;
+
+            if (entry.State == PositionState.RemappedSpan)
+            {
+                return new LineMapping(
+                    unmapped,
+                    characterOffset: entry.UnmappedCharacterOffset,
+                    new FileLinePositionSpan(path, entry.MappedSpan, hasMappedPath));
+            }
+
+            var mappedSpan = new LinePositionSpan(
+                new LinePosition(entry.MappedLine, character: 0),
+                new LinePosition(entry.MappedLine + unmappedEndLine - entry.UnmappedLine, lineLength));
+            var mapped = new FileLinePositionSpan(path, mappedSpan, hasMappedPath);
+            return new LineMapping(unmapped, characterOffset: null, mapped);
         }
     }
 }
diff --git a/src/Compilers/Core/Portable/Syntax/LineMapping.cs b/src/Compilers/Core/Portable/Syntax/LineMapping.cs
index c6be68d43339d..a481c4dc45bcf 100644
--- a/src/Compilers/Core/Portable/Syntax/LineMapping.cs
+++ b/src/Compilers/Core/Portable/Syntax/LineMapping.cs
@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Runtime.Serialization;
+using System.Text;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -19,6 +19,11 @@ namespace Microsoft.CodeAnalysis
         /// </summary>
         public readonly LinePositionSpan Span { get; }
 
+        /// <summary>
+        /// The optional offset in the syntax tree for the line immediately following an enhanced <c>#line</c> directive in C#.
+        /// </summary>
+        public readonly int? CharacterOffset { get; }
+
         /// <summary>
         /// If the line mapping directive maps the span into an explicitly specified file the <see cref="FileLinePositionSpan.HasMappedPath"/> is true.
         /// If the path is not mapped <see cref="FileLinePositionSpan.Path"/> is empty and <see cref="FileLinePositionSpan.HasMappedPath"/> is false.
@@ -26,18 +31,13 @@ namespace Microsoft.CodeAnalysis
         /// </summary>
         public readonly FileLinePositionSpan MappedSpan { get; }
 
-        public LineMapping(LinePositionSpan span, FileLinePositionSpan mappedSpan)
+        public LineMapping(LinePositionSpan span, int? characterOffset, FileLinePositionSpan mappedSpan)
         {
             Span = span;
+            CharacterOffset = characterOffset;
             MappedSpan = mappedSpan;
         }
 
-        public void Deconstruct(out LinePositionSpan span, out FileLinePositionSpan mappedSpan)
-        {
-            span = Span;
-            mappedSpan = MappedSpan;
-        }
-
         /// <summary>
         /// True if the line mapping marks hidden code.
         /// </summary>
@@ -48,10 +48,10 @@ public override bool Equals(object? obj)
             => obj is LineMapping other && Equals(other);
 
         public bool Equals(LineMapping other)
-            => Span.Equals(other.Span) && MappedSpan.Equals(other.MappedSpan);
+            => Span.Equals(other.Span) && CharacterOffset.Equals(other.CharacterOffset) && MappedSpan.Equals(other.MappedSpan);
 
         public override int GetHashCode()
-            => Hash.Combine(Span.GetHashCode(), MappedSpan.GetHashCode());
+            => Hash.Combine(Hash.Combine(Span.GetHashCode(), CharacterOffset.GetHashCode()), MappedSpan.GetHashCode());
 
         public static bool operator ==(LineMapping left, LineMapping right)
             => left.Equals(right);
@@ -60,6 +60,17 @@ public override int GetHashCode()
             => !(left == right);
 
         public override string? ToString()
-            => $"{Span} -> {MappedSpan}";
+        {
+            var builder = new StringBuilder();
+            builder.Append(Span);
+            if (CharacterOffset.HasValue)
+            {
+                builder.Append(",");
+                builder.Append(CharacterOffset.GetValueOrDefault());
+            }
+            builder.Append(" -> ");
+            builder.Append(MappedSpan);
+            return builder.ToString();
+        }
     }
 }
diff --git a/src/Compilers/Core/Portable/Syntax/SyntaxToken.cs b/src/Compilers/Core/Portable/Syntax/SyntaxToken.cs
index 6053d33c739a1..5af910f507e97 100644
--- a/src/Compilers/Core/Portable/Syntax/SyntaxToken.cs
+++ b/src/Compilers/Core/Portable/Syntax/SyntaxToken.cs
@@ -611,7 +611,7 @@ internal SyntaxToken GetNextToken(Func<SyntaxToken, bool> predicate, Func<Syntax
         /// <summary>
         /// Gets the token that precedes this token in the syntax tree.
         /// </summary>
-        /// <returns>The next token that follows this token in the syntax tree.</returns>
+        /// <returns>The previous token that precedes this token in the syntax tree.</returns>
         public SyntaxToken GetPreviousToken(bool includeZeroWidth = false, bool includeSkipped = false, bool includeDirectives = false, bool includeDocumentationComments = false)
         {
             if (Node == null)
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.cs.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.cs.xlf
index bffe57c1a13c2..2b46d31b18f31 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.cs.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.cs.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">Parametr hintName obsahuje neplatný znak {0} na pozici {1}.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">Parametr hintName přidaného zdrojového souboru musí být jedinečný v rámci generátoru.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">Zadaný SourceText musí mít explicitní sadu kódování.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.de.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.de.xlf
index 68f442606092e..3991be208d0bf 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.de.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.de.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">Der hintName enthält ein ungültiges Zeichen "{0}" an Position {1}.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">Der hintName der hinzugefügten Quelldatei muss innerhalb eines Generators eindeutig sein.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">Der angegebene SourceText muss über einen expliziten Codierungssatz verfügen.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.es.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.es.xlf
index 2660993dccd18..40367fb6b6665 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.es.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.es.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">El elemento hintName contiene un carácter "{0}" no válido en la posición {1}.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">El elemento hintName del archivo de código fuente agregado debe ser único en un generador.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">El elemento SourceText proporcionado debe tener un conjunto de codificación explícito.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.fr.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.fr.xlf
index e68fb54360f41..a50dece1c6ff1 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.fr.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.fr.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">Le hintName contient un caractère non valide '{0}' à la position {1}.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">Le hintName du fichier source ajouté doit être unique dans un générateur.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">Le SourceText fourni doit avoir un encodage explicite défini.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.it.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.it.xlf
index 81f68696fc03f..f79e216fc4362 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.it.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.it.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">L'elemento hintName contiene un carattere non valido '{0}' alla posizione {1}.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">L'elemento hintName del file di origine aggiunto deve essere univoco all'interno di un generatore.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">L'elemento SourceText fornito deve avere una codifica esplicita impostata.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ja.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ja.xlf
index 10b686e7706e4..2281871cecf54 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ja.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ja.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">hintName の位置 {1} に無効な文字 '{0}' が含まれています。</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">追加されたソース ファイルの hintName は、ジェネレーター内で一意である必要があります。</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">指定する SourceText には明示的なエンコード セットを含める必要があります。</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ko.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ko.xlf
index e848023414ed1..cadb79f375d4a 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ko.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ko.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">hintName의 {1} 위치에 잘못된 문자 '{0}'이(가) 있습니다.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">추가된 소스 파일의 hintName은 생성기 내에서 고유해야 합니다.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">SourceText에는 명시적인 인코딩 집합이 있어야 합니다.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pl.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pl.xlf
index d1f65d0fee435..4445f583241ab 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pl.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pl.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">Element hintName zawiera nieprawidłowy znak „{0}” na pozycji {1}.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">Element hintName dodanego pliku źródłowego musi być unikatowy w obrębie generatora.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">Podany tekst źródłowy (SourceText) musi mieć zestaw jawnego kodowania.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pt-BR.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pt-BR.xlf
index 2406894be6602..a713d44231c45 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pt-BR.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pt-BR.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">O hintName contém um caractere inválido '{0}' na posição {1}.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">O hintName do arquivo de origem adicionado precisa ser exclusivo em um gerador.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">O SourceText fornecido precisa ter um conjunto de codificação explícito.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ru.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ru.xlf
index 9d3c02ac4990a..493dc6d0e5a92 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ru.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ru.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">Имя подсказки (hintName) содержит недопустимый символ "{0}" в позиции {1}.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">Имя подсказки (hintName) добавленного исходного файла должно быть уникальным в пределах генератора.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">Предоставленный SourceText должен иметь явный набор кодировок.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf
index 3f40cca4931a2..26f4210ff25b1 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">hintName, {1} konumunda geçersiz bir '{0}' karakteri içeriyor.</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">Eklenen kaynak dosyanın hintName'i bir oluşturucu içinde benzersiz olmalıdır.</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">Sağlanan SourceText'in açık bir kodlama kümesi olmalıdır.</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hans.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hans.xlf
index 373839f5998d6..34684819feff5 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hans.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hans.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">HintName 包含位置 {1} 处的无效字符 "{0}"。</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">添加的源文件的 hintName 在生成器中必须唯一。</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">提供的 SourceText 必须具有显式编码集。</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hant.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hant.xlf
index bd4e10e25f020..3cf9076af372f 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hant.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hant.xlf
@@ -40,14 +40,14 @@
         <note>{0}: Comma-separated list of diagnostic IDs</note>
       </trans-unit>
       <trans-unit id="HintNameInvalidChar">
-        <source>The hintName contains an invalid character '{0}' at position {1}.</source>
-        <target state="translated">位置 {1} 的 hintName 包含無效的字元 '{0}'。</target>
-        <note>{0}: the invalid character, {1} the position it occurred at</note>
+        <source>The hintName '{0}' contains an invalid character '{1}' at position {2}.</source>
+        <target state="new">The hintName '{0}' contains an invalid character '{1}' at position {2}.</target>
+        <note>{0}: the provided hintname. {1}: the invalid character, {2} the position it occurred at</note>
       </trans-unit>
       <trans-unit id="HintNameUniquePerGenerator">
-        <source>The hintName of the added source file must be unique within a generator.</source>
-        <target state="translated">新增之來源檔案的 hintName，在產生器中必須是唯一的。</target>
-        <note />
+        <source>The hintName '{0}' of the added source file must be unique within a generator.</source>
+        <target state="new">The hintName '{0}' of the added source file must be unique within a generator.</target>
+        <note>{0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="InvalidAdditionalFile">
         <source>Additional file doesn't belong to the underlying 'CompilationWithAnalyzers'.</source>
@@ -125,9 +125,9 @@
         <note>{0}: type name</note>
       </trans-unit>
       <trans-unit id="SourceTextRequiresEncoding">
-        <source>The provided SourceText must have an explicit encoding set.</source>
-        <target state="translated">提供的 SourceText 必須有明確的編碼集。</target>
-        <note>'SourceText' is not localizable.</note>
+        <source>The SourceText with hintName '{0}' must have an explicit encoding set.</source>
+        <target state="new">The SourceText with hintName '{0}' must have an explicit encoding set.</target>
+        <note>'SourceText' is not localizable. {0}: the provided hintname</note>
       </trans-unit>
       <trans-unit id="SupportedDiagnosticsHasNullDescriptor">
         <source>Analyzer '{0}' contains a null descriptor in its 'SupportedDiagnostics'.</source>
diff --git a/src/Compilers/Test/Core/ExceptionHelper.cs b/src/Compilers/Test/Core/ExceptionHelper.cs
index 51f759f84bbe3..c41608a7c7b56 100644
--- a/src/Compilers/Test/Core/ExceptionHelper.cs
+++ b/src/Compilers/Test/Core/ExceptionHelper.cs
@@ -58,7 +58,7 @@ internal static string GetMessageFromResult(string expectedOutput, string actual
             {
                 sb.Append("Expected: ");
                 sb.AppendLine(expectedOutput);
-                sb.Append("Actual:   ");
+                sb.Append("Actual: ");
                 sb.AppendLine(actualOutput);
             }
             else
diff --git a/src/Compilers/Test/Core/SourceGeneration/LambdaComparer.cs b/src/Compilers/Test/Core/SourceGeneration/LambdaComparer.cs
new file mode 100644
index 0000000000000..7c9e829783779
--- /dev/null
+++ b/src/Compilers/Test/Core/SourceGeneration/LambdaComparer.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Roslyn.Test.Utilities.TestGenerators
+{
+    public sealed class LambdaComparer<T> : IEqualityComparer<T>
+    {
+        private readonly Func<T?, T?, bool> _equal;
+        private readonly int? _hashCode;
+
+        public LambdaComparer(Func<T?, T?, bool> equal, int? hashCode = null)
+        {
+            _equal = equal;
+            _hashCode = hashCode;
+        }
+
+        public bool Equals(T? x, T? y) => _equal(x, y);
+
+        public int GetHashCode([DisallowNull] T obj) => _hashCode.HasValue ? _hashCode.Value : EqualityComparer<T>.Default.GetHashCode(obj);
+    }
+}
diff --git a/src/Compilers/Test/Core/SourceGeneration/TestGenerators.cs b/src/Compilers/Test/Core/SourceGeneration/TestGenerators.cs
index 5beea3fae7517..57217b7bdad0a 100644
--- a/src/Compilers/Test/Core/SourceGeneration/TestGenerators.cs
+++ b/src/Compilers/Test/Core/SourceGeneration/TestGenerators.cs
@@ -70,49 +70,56 @@ public CallbackGenerator2(Action<GeneratorInitializationContext> onInit, Action<
         }
     }
 
-    internal class AdditionalFileAddedGenerator : ISourceGenerator
+    internal class InMemoryAdditionalText : AdditionalText
     {
-        public bool CanApplyChanges { get; set; } = true;
+        private readonly SourceText _content;
 
-        public void Execute(GeneratorExecutionContext context)
+        public InMemoryAdditionalText(string path, string content)
         {
-            foreach (var file in context.AdditionalFiles)
-            {
-                context.AddSource(GetGeneratedFileName(file.Path), SourceText.From("", Encoding.UTF8));
-            }
+            Path = path;
+            _content = SourceText.From(content, Encoding.UTF8);
         }
 
-        public void Initialize(GeneratorInitializationContext context)
-        {
-            context.RegisterForAdditionalFileChanges(UpdateContext);
-        }
+        public override string Path { get; }
+
+        public override SourceText GetText(CancellationToken cancellationToken = default) => _content;
+
+    }
 
-        bool UpdateContext(GeneratorEditContext context, AdditionalFileEdit edit)
+    internal sealed class PipelineCallbackGenerator : IIncrementalGenerator
+    {
+        private readonly Action<IncrementalGeneratorInitializationContext> _registerPipelineCallback;
+
+        public PipelineCallbackGenerator(Action<IncrementalGeneratorInitializationContext> registerPipelineCallback)
         {
-            if (edit is AdditionalFileAddedEdit add && CanApplyChanges)
-            {
-                context.AdditionalSources.Add(GetGeneratedFileName(add.AddedText.Path), SourceText.From("", Encoding.UTF8));
-                return true;
-            }
-            return false;
+            _registerPipelineCallback = registerPipelineCallback;
         }
 
-        private string GetGeneratedFileName(string path) => $"{Path.GetFileNameWithoutExtension(path.Replace('\\', Path.DirectorySeparatorChar))}.generated";
+        public void Initialize(IncrementalGeneratorInitializationContext context) => _registerPipelineCallback(context);
     }
 
-    internal class InMemoryAdditionalText : AdditionalText
+    internal sealed class PipelineCallbackGenerator2 : IIncrementalGenerator
     {
-        private readonly SourceText _content;
+        private readonly Action<IncrementalGeneratorInitializationContext> _registerPipelineCallback;
 
-        public InMemoryAdditionalText(string path, string content)
+        public PipelineCallbackGenerator2(Action<IncrementalGeneratorInitializationContext> registerPipelineCallback)
         {
-            Path = path;
-            _content = SourceText.From(content, Encoding.UTF8);
+            _registerPipelineCallback = registerPipelineCallback;
         }
 
-        public override string Path { get; }
+        public void Initialize(IncrementalGeneratorInitializationContext context) => _registerPipelineCallback(context);
+    }
 
-        public override SourceText GetText(CancellationToken cancellationToken = default) => _content;
+    internal sealed class IncrementalAndSourceCallbackGenerator : CallbackGenerator, IIncrementalGenerator
+    {
+        private readonly Action<IncrementalGeneratorInitializationContext> _onInit;
+
+        public IncrementalAndSourceCallbackGenerator(Action<GeneratorInitializationContext> onInit, Action<GeneratorExecutionContext> onExecute, Action<IncrementalGeneratorInitializationContext> onIncrementalInit)
+            : base(onInit, onExecute)
+        {
+            _onInit = onIncrementalInit;
+        }
 
+        public void Initialize(IncrementalGeneratorInitializationContext context) => _onInit(context);
     }
 }
diff --git a/src/Compilers/Test/Core/TargetFrameworkUtil.cs b/src/Compilers/Test/Core/TargetFrameworkUtil.cs
index 19e683b3fe892..900d4149e9e33 100644
--- a/src/Compilers/Test/Core/TargetFrameworkUtil.cs
+++ b/src/Compilers/Test/Core/TargetFrameworkUtil.cs
@@ -23,6 +23,7 @@ public enum TargetFramework
 
         NetStandard20,
         NetCoreApp,
+        NetCoreAppAndCSharp,
         WinRT,
 
         /// <summary>
@@ -97,6 +98,7 @@ public static class TargetFrameworkUtil
         public static ImmutableArray<MetadataReference> NetCoreAppReferences => ImmutableArray.Create<MetadataReference>(NetCoreApp.netstandard, NetCoreApp.mscorlib, NetCoreApp.SystemRuntime, NetCoreApp.SystemCore,
                                                                                                                            NetCoreApp.SystemConsole, NetCoreApp.SystemLinq, NetCoreApp.SystemLinqExpressions, NetCoreApp.SystemThreadingTasks,
                                                                                                                            NetCoreApp.SystemCollections);
+        public static ImmutableArray<MetadataReference> NetCoreAppReferencesAndCSharp => NetCoreAppReferences.Add(NetCoreApp.MicrosoftCSharp);
         public static ImmutableArray<MetadataReference> WinRTReferences => ImmutableArray.Create(TestBase.WinRtRefs);
         public static ImmutableArray<MetadataReference> StandardReferences => RuntimeUtilities.IsCoreClrRuntime ? NetStandard20References : Mscorlib46ExtendedReferences;
         public static ImmutableArray<MetadataReference> StandardLatestReferences => RuntimeUtilities.IsCoreClrRuntime ? NetCoreAppReferences : Mscorlib46ExtendedReferences;
@@ -124,6 +126,7 @@ public static class TargetFrameworkUtil
             TargetFramework.Mscorlib461Extended => Mscorlib461ExtendedReferences,
             TargetFramework.NetStandard20 => NetStandard20References,
             TargetFramework.NetCoreApp => NetCoreAppReferences,
+            TargetFramework.NetCoreAppAndCSharp => NetCoreAppReferencesAndCSharp,
             TargetFramework.WinRT => WinRTReferences,
             TargetFramework.Standard => StandardReferences,
             TargetFramework.StandardLatest => StandardLatestReferences,
diff --git a/src/Compilers/Test/Core/TestResource.resx b/src/Compilers/Test/Core/TestResource.resx
index c337fa629026e..92ff5df0788cc 100644
--- a/src/Compilers/Test/Core/TestResource.resx
+++ b/src/Compilers/Test/Core/TestResource.resx
@@ -867,7 +867,9 @@ namespace Comments.XmlComments.UndocumentedKeywords
 #line 6
 #line 2 "test.cs"
 #line default
-#line hidden</value>
+#line hidden
+#line (1, 1) - (2, 2) 3 "test.cs"
+</value>
   </data>
   <data name="AllInOneVisualBasicBaseline" xml:space="preserve">
     <value>Option Infer On
diff --git a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
index 49e10d3d428c1..f3e1460af9b33 100644
--- a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
@@ -876,7 +876,7 @@ public static SyntaxTree Parse(string text, string filename = "", CSharpParseOpt
         {
             if ((object)options == null)
             {
-                options = TestOptions.Regular;
+                options = TestOptions.RegularPreview;
             }
 
             var stringText = StringText.From(text, encoding ?? Encoding.UTF8);
@@ -1116,7 +1116,7 @@ private static CSharpCompilation CreateCompilationCore(
 
             if (experimentalFeature.HasValue)
             {
-                parseOptions = (parseOptions ?? TestOptions.Regular).WithExperimental(experimentalFeature.Value);
+                parseOptions = (parseOptions ?? TestOptions.RegularPreview).WithExperimental(experimentalFeature.Value);
             }
 
             Func<CSharpCompilation> createCompilationLambda = () => CSharpCompilation.Create(
diff --git a/src/Compilers/Test/Utilities/CSharp/TestOptions.cs b/src/Compilers/Test/Utilities/CSharp/TestOptions.cs
index e5bba5b842d74..9dcee21970d7c 100644
--- a/src/Compilers/Test/Utilities/CSharp/TestOptions.cs
+++ b/src/Compilers/Test/Utilities/CSharp/TestOptions.cs
@@ -23,9 +23,17 @@ public static class TestOptions
         public static readonly CSharpParseOptions Regular7_2 = Regular.WithLanguageVersion(LanguageVersion.CSharp7_2);
         public static readonly CSharpParseOptions Regular7_3 = Regular.WithLanguageVersion(LanguageVersion.CSharp7_3);
         public static readonly CSharpParseOptions RegularDefault = Regular.WithLanguageVersion(LanguageVersion.Default);
+
+        /// <summary>
+        /// Usages of <see cref="TestOptions.RegularNext"/> and <see cref="LanguageVersionFacts.CSharpNext"/>
+        /// will be replaced with TestOptions.RegularN and LanguageVersion.CSharpN when language version N is introduced.
+        /// </summary>
+        public static readonly CSharpParseOptions RegularNext = Regular.WithLanguageVersion(LanguageVersion.Preview);
+
         public static readonly CSharpParseOptions RegularPreview = Regular.WithLanguageVersion(LanguageVersion.Preview);
         public static readonly CSharpParseOptions Regular8 = Regular.WithLanguageVersion(LanguageVersion.CSharp8);
         public static readonly CSharpParseOptions Regular9 = Regular.WithLanguageVersion(LanguageVersion.CSharp9);
+        public static readonly CSharpParseOptions Regular10 = Regular.WithLanguageVersion(LanguageVersion.CSharp10);
         public static readonly CSharpParseOptions RegularWithDocumentationComments = Regular.WithDocumentationMode(DocumentationMode.Diagnose);
         public static readonly CSharpParseOptions RegularWithLegacyStrongName = Regular.WithFeature("UseLegacyStrongNameProvider");
         public static readonly CSharpParseOptions WithoutImprovedOverloadCandidates = Regular.WithLanguageVersion(MessageID.IDS_FeatureImprovedOverloadCandidates.RequiredVersion() - 1);
diff --git a/src/Compilers/VisualBasic/Portable/Binding/Binder_Initializers.vb b/src/Compilers/VisualBasic/Portable/Binding/Binder_Initializers.vb
index 43b82752bf89e..a6c39e398b68b 100644
--- a/src/Compilers/VisualBasic/Portable/Binding/Binder_Initializers.vb
+++ b/src/Compilers/VisualBasic/Portable/Binding/Binder_Initializers.vb
@@ -246,7 +246,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim initializer = New BoundFieldInitializer(syntax,
                                                         ImmutableArray.Create(Of FieldSymbol)(fieldSymbol),
                                                         boundFieldAccessExpression,
-                                                        arrayCreation)
+                                                        arrayCreation,
+                                                        binderOpt:=Nothing)
 
             boundInitializers.Add(initializer)
         End Sub
@@ -283,21 +284,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                                       firstFieldSymbol.Type)
             fieldAccess.SetWasCompilerGenerated()
 
-            Dim asNewVariablePlaceholder As BoundWithLValueExpressionPlaceholder = Nothing
-            If equalsValueOrAsNewSyntax.Kind = SyntaxKind.AsNewClause Then
-                ' CONSIDER: using a bound field access directly instead of a placeholder for AsNew declarations
-                '           with just one variable
-
-                asNewVariablePlaceholder = New BoundWithLValueExpressionPlaceholder(equalsValueOrAsNewSyntax,
-                                                                                    firstFieldSymbol.Type)
-                asNewVariablePlaceholder.SetWasCompilerGenerated()
-            End If
-
-            Dim boundInitExpression As BoundExpression = BindFieldOrPropertyInitializerExpression(equalsValueOrAsNewSyntax,
-                                                                                                  firstFieldSymbol.Type,
-                                                                                                  asNewVariablePlaceholder,
-                                                                                                  diagnostics)
-
+            Dim boundInitExpression As BoundExpression = BindFieldInitializerExpression(equalsValueOrAsNewSyntax, firstFieldSymbol, diagnostics)
             Dim hasErrors = False
 
             ' In speculative semantic model scenarios equalsValueOrAsNewSyntax might have no parent.
@@ -321,9 +308,28 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 fieldSymbols,
                 If(fieldSymbols.Length = 1, fieldAccess, Nothing),
                 boundInitExpression,
+                Me,
                 hasErrors))
         End Sub
 
+        Friend Function BindFieldInitializerExpression(equalsValueOrAsNewSyntax As SyntaxNode, fieldSymbol As FieldSymbol, diagnostics As BindingDiagnosticBag) As BoundExpression
+            Dim asNewVariablePlaceholder As BoundWithLValueExpressionPlaceholder = Nothing
+            If equalsValueOrAsNewSyntax.Kind = SyntaxKind.AsNewClause Then
+                ' CONSIDER: using a bound field access directly instead of a placeholder for AsNew declarations
+                '           with just one variable
+
+                asNewVariablePlaceholder = New BoundWithLValueExpressionPlaceholder(equalsValueOrAsNewSyntax,
+                                                                                    fieldSymbol.Type)
+                asNewVariablePlaceholder.SetWasCompilerGenerated()
+            End If
+
+            Dim boundInitExpression As BoundExpression = BindFieldOrPropertyInitializerExpression(equalsValueOrAsNewSyntax,
+                                                                                                  fieldSymbol.Type,
+                                                                                                  asNewVariablePlaceholder,
+                                                                                                  diagnostics)
+            Return boundInitExpression
+        End Function
+
         Friend Sub BindPropertyInitializer(
             propertySymbols As ImmutableArray(Of PropertySymbol),
             initValueOrAsNewNode As SyntaxNode,
@@ -367,18 +373,21 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             boundPropertyOrFieldAccess = AdjustAssignmentTarget(syntaxNode, boundPropertyOrFieldAccess, diagnostics, isError)
             boundPropertyOrFieldAccess.SetWasCompilerGenerated()
 
-            Dim boundInitExpression = BindFieldOrPropertyInitializerExpression(initValueOrAsNewNode,
-                                                                               propertySymbol.Type,
-                                                                               Nothing,
-                                                                               diagnostics)
-
+            Dim boundInitExpression As BoundExpression = BindPropertyInitializerExpression(initValueOrAsNewNode, propertySymbol, diagnostics)
             boundInitializers.Add(New BoundPropertyInitializer(initValueOrAsNewNode,
                                                                propertySymbols,
                                                                If(propertySymbols.Length = 1, boundPropertyOrFieldAccess, Nothing),
-                                                               boundInitExpression))
-
+                                                               boundInitExpression,
+                                                               Me))
         End Sub
 
+        Friend Function BindPropertyInitializerExpression(initValueOrAsNewNode As SyntaxNode, propertySymbol As PropertySymbol, diagnostics As BindingDiagnosticBag) As BoundExpression
+            Return BindFieldOrPropertyInitializerExpression(initValueOrAsNewNode,
+                                                            propertySymbol.Type,
+                                                            Nothing,
+                                                            diagnostics)
+        End Function
+
         Private Function BindFieldOrPropertyInitializerExpression(
             equalsValueOrAsNewSyntax As SyntaxNode,
             targetType As TypeSymbol,
@@ -468,7 +477,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 boundInitializers.Add(New BoundFieldInitializer(equalsValueOrAsNewSyntax,
                                                                 ImmutableArray.Create(Of FieldSymbol)(fieldSymbol),
                                                                 boundFieldAccessExpr,
-                                                                boundInitValue))
+                                                                boundInitValue,
+                                                                binderOpt:=Nothing))
             End If
         End Sub
 
diff --git a/src/Compilers/VisualBasic/Portable/Binding/Binder_ObjectInitializer.vb b/src/Compilers/VisualBasic/Portable/Binding/Binder_ObjectInitializer.vb
index 3d0e0219bb166..697a8aea24980 100644
--- a/src/Compilers/VisualBasic/Portable/Binding/Binder_ObjectInitializer.vb
+++ b/src/Compilers/VisualBasic/Portable/Binding/Binder_ObjectInitializer.vb
@@ -622,7 +622,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
                 Return New BoundObjectInitializerExpression(objectCreationSyntax.Initializer,
                                                             True,
-                                                            Me,
                                                             variableOrTempPlaceholder,
                                                             boundAssignmentValues.AsImmutableOrNull,
                                                             initializedObjectType,
@@ -744,7 +743,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
             Return New BoundObjectInitializerExpression(objectCreationSyntax.Initializer,
                                                         createTemporary,
-                                                        Me,
                                                         variableOrTempPlaceholder,
                                                         memberAssignments.ToImmutableAndFree,
                                                         initializedObjectType)
diff --git a/src/Compilers/VisualBasic/Portable/Binding/Binder_Statements.vb b/src/Compilers/VisualBasic/Portable/Binding/Binder_Statements.vb
index c9a100643b139..4a6f1aee8300a 100644
--- a/src/Compilers/VisualBasic/Portable/Binding/Binder_Statements.vb
+++ b/src/Compilers/VisualBasic/Portable/Binding/Binder_Statements.vb
@@ -1045,7 +1045,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     Next
 #End If
 
-                    builder.Add(New BoundAsNewLocalDeclarations(varDecl, locals.ToImmutableAndFree(), asNewInitializer))
+                    builder.Add(New BoundAsNewLocalDeclarations(varDecl, locals.ToImmutableAndFree(), asNewInitializer, Me))
                 End If
             Next
 
diff --git a/src/Compilers/VisualBasic/Portable/Binding/InitializerSemanticModel.vb b/src/Compilers/VisualBasic/Portable/Binding/InitializerSemanticModel.vb
index dd02a8d24fd1c..2f645354248ea 100644
--- a/src/Compilers/VisualBasic/Portable/Binding/InitializerSemanticModel.vb
+++ b/src/Compilers/VisualBasic/Portable/Binding/InitializerSemanticModel.vb
@@ -134,7 +134,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
                     Dim expressionInitializer = TryCast(boundInitializer, BoundExpression)
                     If expressionInitializer IsNot Nothing Then
-                        Return New BoundFieldInitializer(initializer, ImmutableArray.Create(DirectCast(Me.MemberSymbol, FieldSymbol)), Nothing, expressionInitializer)
+                        Return New BoundFieldInitializer(initializer, ImmutableArray.Create(DirectCast(Me.MemberSymbol, FieldSymbol)), Nothing, expressionInitializer, binderOpt:=Nothing)
                     End If
 
                 Case SymbolKind.Property
@@ -147,7 +147,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
                     Dim expressionInitializer = TryCast(boundInitializer, BoundExpression)
                     If expressionInitializer IsNot Nothing Then
-                        Return New BoundPropertyInitializer(initializer, propertySymbols, Nothing, expressionInitializer)
+                        Return New BoundPropertyInitializer(initializer, propertySymbols, Nothing, expressionInitializer, binderOpt:=Nothing)
                     End If
 
                 Case SymbolKind.Parameter
diff --git a/src/Compilers/VisualBasic/Portable/BoundTree/BoundNodes.xml b/src/Compilers/VisualBasic/Portable/BoundTree/BoundNodes.xml
index b54295a41032f..48e4415568baa 100644
--- a/src/Compilers/VisualBasic/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/VisualBasic/Portable/BoundTree/BoundNodes.xml
@@ -869,7 +869,6 @@
     -->
     <Node Name="BoundObjectInitializerExpression" Base="BoundObjectInitializerExpressionBase" HasValidate="true">
       <Field Name="CreateTemporaryLocalForInitialization" Type="Boolean" />
-      <Field Name="Binder" Type="Binder" Null="disallow" />
     </Node>
 
     <!-- 
@@ -1037,6 +1036,7 @@
     <Node Name="BoundAsNewLocalDeclarations" Base="BoundLocalDeclarationBase">
         <Field Name="LocalDeclarations" Type="ImmutableArray(Of BoundLocalDeclaration)" />
         <Field Name="Initializer" Type="BoundExpression" />
+        <Field Name="Binder" Type="Binder" Null="disallow" />
     </Node>
 
     <!--
@@ -1065,6 +1065,7 @@
     <Field Name="MemberAccessExpressionOpt" Type="BoundExpression" Null="allow" />
     <!-- The expression representing the initial value -->
     <Field Name="InitialValue" Type="BoundExpression" Null="disallow"/>
+    <Field Name="BinderOpt" Type="Binder" Null="allow" />
   </AbstractNode>
 
   <!-- Bound node that represents a field initialization. --> 
diff --git a/src/Compilers/VisualBasic/Portable/Generated/BoundNodes.xml.Generated.vb b/src/Compilers/VisualBasic/Portable/Generated/BoundNodes.xml.Generated.vb
index 08fbbf38055a0..9dd3584870b2a 100644
--- a/src/Compilers/VisualBasic/Portable/Generated/BoundNodes.xml.Generated.vb
+++ b/src/Compilers/VisualBasic/Portable/Generated/BoundNodes.xml.Generated.vb
@@ -3758,14 +3758,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Partial Friend NotInheritable Class BoundObjectInitializerExpression
         Inherits BoundObjectInitializerExpressionBase
 
-        Public Sub New(syntax As SyntaxNode, createTemporaryLocalForInitialization As Boolean, binder As Binder, placeholderOpt As BoundWithLValueExpressionPlaceholder, initializers As ImmutableArray(Of BoundExpression), type As TypeSymbol, Optional hasErrors As Boolean = False)
+        Public Sub New(syntax As SyntaxNode, createTemporaryLocalForInitialization As Boolean, placeholderOpt As BoundWithLValueExpressionPlaceholder, initializers As ImmutableArray(Of BoundExpression), type As TypeSymbol, Optional hasErrors As Boolean = False)
             MyBase.New(BoundKind.ObjectInitializerExpression, syntax, placeholderOpt, initializers, type, hasErrors OrElse placeholderOpt.NonNullAndHasErrors() OrElse initializers.NonNullAndHasErrors())
 
-            Debug.Assert(binder IsNot Nothing, "Field 'binder' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
             Debug.Assert(Not (initializers.IsDefault), "Field 'initializers' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
 
             Me._CreateTemporaryLocalForInitialization = createTemporaryLocalForInitialization
-            Me._Binder = binder
 
             Validate()
         End Sub
@@ -3781,21 +3779,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
-        Private ReadOnly _Binder As Binder
-        Public ReadOnly Property Binder As Binder
-            Get
-                Return _Binder
-            End Get
-        End Property
-
         <DebuggerStepThrough>
         Public Overrides Function Accept(visitor as BoundTreeVisitor) As BoundNode
             Return visitor.VisitObjectInitializerExpression(Me)
         End Function
 
-        Public Function Update(createTemporaryLocalForInitialization As Boolean, binder As Binder, placeholderOpt As BoundWithLValueExpressionPlaceholder, initializers As ImmutableArray(Of BoundExpression), type As TypeSymbol) As BoundObjectInitializerExpression
-            If createTemporaryLocalForInitialization <> Me.CreateTemporaryLocalForInitialization OrElse binder IsNot Me.Binder OrElse placeholderOpt IsNot Me.PlaceholderOpt OrElse initializers <> Me.Initializers OrElse type IsNot Me.Type Then
-                Dim result = New BoundObjectInitializerExpression(Me.Syntax, createTemporaryLocalForInitialization, binder, placeholderOpt, initializers, type, Me.HasErrors)
+        Public Function Update(createTemporaryLocalForInitialization As Boolean, placeholderOpt As BoundWithLValueExpressionPlaceholder, initializers As ImmutableArray(Of BoundExpression), type As TypeSymbol) As BoundObjectInitializerExpression
+            If createTemporaryLocalForInitialization <> Me.CreateTemporaryLocalForInitialization OrElse placeholderOpt IsNot Me.PlaceholderOpt OrElse initializers <> Me.Initializers OrElse type IsNot Me.Type Then
+                Dim result = New BoundObjectInitializerExpression(Me.Syntax, createTemporaryLocalForInitialization, placeholderOpt, initializers, type, Me.HasErrors)
                 result.CopyAttributes(Me)
                 Return result
             End If
@@ -4500,14 +4491,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Partial Friend NotInheritable Class BoundAsNewLocalDeclarations
         Inherits BoundLocalDeclarationBase
 
-        Public Sub New(syntax As SyntaxNode, localDeclarations As ImmutableArray(Of BoundLocalDeclaration), initializer As BoundExpression, Optional hasErrors As Boolean = False)
+        Public Sub New(syntax As SyntaxNode, localDeclarations As ImmutableArray(Of BoundLocalDeclaration), initializer As BoundExpression, binder As Binder, Optional hasErrors As Boolean = False)
             MyBase.New(BoundKind.AsNewLocalDeclarations, syntax, hasErrors OrElse localDeclarations.NonNullAndHasErrors() OrElse initializer.NonNullAndHasErrors())
 
             Debug.Assert(Not (localDeclarations.IsDefault), "Field 'localDeclarations' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
             Debug.Assert(initializer IsNot Nothing, "Field 'initializer' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
+            Debug.Assert(binder IsNot Nothing, "Field 'binder' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
 
             Me._LocalDeclarations = localDeclarations
             Me._Initializer = initializer
+            Me._Binder = binder
         End Sub
 
 
@@ -4525,14 +4518,21 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
+        Private ReadOnly _Binder As Binder
+        Public ReadOnly Property Binder As Binder
+            Get
+                Return _Binder
+            End Get
+        End Property
+
         <DebuggerStepThrough>
         Public Overrides Function Accept(visitor as BoundTreeVisitor) As BoundNode
             Return visitor.VisitAsNewLocalDeclarations(Me)
         End Function
 
-        Public Function Update(localDeclarations As ImmutableArray(Of BoundLocalDeclaration), initializer As BoundExpression) As BoundAsNewLocalDeclarations
-            If localDeclarations <> Me.LocalDeclarations OrElse initializer IsNot Me.Initializer Then
-                Dim result = New BoundAsNewLocalDeclarations(Me.Syntax, localDeclarations, initializer, Me.HasErrors)
+        Public Function Update(localDeclarations As ImmutableArray(Of BoundLocalDeclaration), initializer As BoundExpression, binder As Binder) As BoundAsNewLocalDeclarations
+            If localDeclarations <> Me.LocalDeclarations OrElse initializer IsNot Me.Initializer OrElse binder IsNot Me.Binder Then
+                Dim result = New BoundAsNewLocalDeclarations(Me.Syntax, localDeclarations, initializer, binder, Me.HasErrors)
                 result.CopyAttributes(Me)
                 Return result
             End If
@@ -4611,13 +4611,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Partial Friend MustInherit Class BoundFieldOrPropertyInitializer
         Inherits BoundInitializer
 
-        Protected Sub New(kind As BoundKind, syntax as SyntaxNode, memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression, Optional hasErrors As Boolean = False)
+        Protected Sub New(kind As BoundKind, syntax as SyntaxNode, memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression, binderOpt As Binder, Optional hasErrors As Boolean = False)
             MyBase.New(kind, syntax, hasErrors)
 
             Debug.Assert(initialValue IsNot Nothing, "Field 'initialValue' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
 
             Me._MemberAccessExpressionOpt = memberAccessExpressionOpt
             Me._InitialValue = initialValue
+            Me._BinderOpt = binderOpt
         End Sub
 
 
@@ -4634,13 +4635,20 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Return _InitialValue
             End Get
         End Property
+
+        Private ReadOnly _BinderOpt As Binder
+        Public ReadOnly Property BinderOpt As Binder
+            Get
+                Return _BinderOpt
+            End Get
+        End Property
     End Class
 
     Partial Friend NotInheritable Class BoundFieldInitializer
         Inherits BoundFieldOrPropertyInitializer
 
-        Public Sub New(syntax As SyntaxNode, initializedFields As ImmutableArray(Of FieldSymbol), memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression, Optional hasErrors As Boolean = False)
-            MyBase.New(BoundKind.FieldInitializer, syntax, memberAccessExpressionOpt, initialValue, hasErrors OrElse memberAccessExpressionOpt.NonNullAndHasErrors() OrElse initialValue.NonNullAndHasErrors())
+        Public Sub New(syntax As SyntaxNode, initializedFields As ImmutableArray(Of FieldSymbol), memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression, binderOpt As Binder, Optional hasErrors As Boolean = False)
+            MyBase.New(BoundKind.FieldInitializer, syntax, memberAccessExpressionOpt, initialValue, binderOpt, hasErrors OrElse memberAccessExpressionOpt.NonNullAndHasErrors() OrElse initialValue.NonNullAndHasErrors())
 
             Debug.Assert(Not (initializedFields.IsDefault), "Field 'initializedFields' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
             Debug.Assert(initialValue IsNot Nothing, "Field 'initialValue' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
@@ -4661,9 +4669,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return visitor.VisitFieldInitializer(Me)
         End Function
 
-        Public Function Update(initializedFields As ImmutableArray(Of FieldSymbol), memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression) As BoundFieldInitializer
-            If initializedFields <> Me.InitializedFields OrElse memberAccessExpressionOpt IsNot Me.MemberAccessExpressionOpt OrElse initialValue IsNot Me.InitialValue Then
-                Dim result = New BoundFieldInitializer(Me.Syntax, initializedFields, memberAccessExpressionOpt, initialValue, Me.HasErrors)
+        Public Function Update(initializedFields As ImmutableArray(Of FieldSymbol), memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression, binderOpt As Binder) As BoundFieldInitializer
+            If initializedFields <> Me.InitializedFields OrElse memberAccessExpressionOpt IsNot Me.MemberAccessExpressionOpt OrElse initialValue IsNot Me.InitialValue OrElse binderOpt IsNot Me.BinderOpt Then
+                Dim result = New BoundFieldInitializer(Me.Syntax, initializedFields, memberAccessExpressionOpt, initialValue, binderOpt, Me.HasErrors)
                 result.CopyAttributes(Me)
                 Return result
             End If
@@ -4674,8 +4682,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Partial Friend NotInheritable Class BoundPropertyInitializer
         Inherits BoundFieldOrPropertyInitializer
 
-        Public Sub New(syntax As SyntaxNode, initializedProperties As ImmutableArray(Of PropertySymbol), memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression, Optional hasErrors As Boolean = False)
-            MyBase.New(BoundKind.PropertyInitializer, syntax, memberAccessExpressionOpt, initialValue, hasErrors OrElse memberAccessExpressionOpt.NonNullAndHasErrors() OrElse initialValue.NonNullAndHasErrors())
+        Public Sub New(syntax As SyntaxNode, initializedProperties As ImmutableArray(Of PropertySymbol), memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression, binderOpt As Binder, Optional hasErrors As Boolean = False)
+            MyBase.New(BoundKind.PropertyInitializer, syntax, memberAccessExpressionOpt, initialValue, binderOpt, hasErrors OrElse memberAccessExpressionOpt.NonNullAndHasErrors() OrElse initialValue.NonNullAndHasErrors())
 
             Debug.Assert(Not (initializedProperties.IsDefault), "Field 'initializedProperties' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
             Debug.Assert(initialValue IsNot Nothing, "Field 'initialValue' cannot be null (use Null=""allow"" in BoundNodes.xml to remove this check)")
@@ -4696,9 +4704,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return visitor.VisitPropertyInitializer(Me)
         End Function
 
-        Public Function Update(initializedProperties As ImmutableArray(Of PropertySymbol), memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression) As BoundPropertyInitializer
-            If initializedProperties <> Me.InitializedProperties OrElse memberAccessExpressionOpt IsNot Me.MemberAccessExpressionOpt OrElse initialValue IsNot Me.InitialValue Then
-                Dim result = New BoundPropertyInitializer(Me.Syntax, initializedProperties, memberAccessExpressionOpt, initialValue, Me.HasErrors)
+        Public Function Update(initializedProperties As ImmutableArray(Of PropertySymbol), memberAccessExpressionOpt As BoundExpression, initialValue As BoundExpression, binderOpt As Binder) As BoundPropertyInitializer
+            If initializedProperties <> Me.InitializedProperties OrElse memberAccessExpressionOpt IsNot Me.MemberAccessExpressionOpt OrElse initialValue IsNot Me.InitialValue OrElse binderOpt IsNot Me.BinderOpt Then
+                Dim result = New BoundPropertyInitializer(Me.Syntax, initializedProperties, memberAccessExpressionOpt, initialValue, binderOpt, Me.HasErrors)
                 result.CopyAttributes(Me)
                 Return result
             End If
@@ -12421,7 +12429,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim placeholderOpt As BoundWithLValueExpressionPlaceholder = DirectCast(Me.Visit(node.PlaceholderOpt), BoundWithLValueExpressionPlaceholder)
             Dim initializers As ImmutableArray(Of BoundExpression) = Me.VisitList(node.Initializers)
             Dim type as TypeSymbol = Me.VisitType(node.Type)
-            Return node.Update(node.CreateTemporaryLocalForInitialization, node.Binder, placeholderOpt, initializers, type)
+            Return node.Update(node.CreateTemporaryLocalForInitialization, placeholderOpt, initializers, type)
         End Function
 
         Public Overrides Function VisitCollectionInitializerExpression(node As BoundCollectionInitializerExpression) As BoundNode
@@ -12506,7 +12514,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Public Overrides Function VisitAsNewLocalDeclarations(node As BoundAsNewLocalDeclarations) As BoundNode
             Dim localDeclarations As ImmutableArray(Of BoundLocalDeclaration) = Me.VisitList(node.LocalDeclarations)
             Dim initializer As BoundExpression = DirectCast(Me.Visit(node.Initializer), BoundExpression)
-            Return node.Update(localDeclarations, initializer)
+            Return node.Update(localDeclarations, initializer, node.Binder)
         End Function
 
         Public Overrides Function VisitDimStatement(node As BoundDimStatement) As BoundNode
@@ -12522,13 +12530,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Public Overrides Function VisitFieldInitializer(node As BoundFieldInitializer) As BoundNode
             Dim memberAccessExpressionOpt As BoundExpression = DirectCast(Me.Visit(node.MemberAccessExpressionOpt), BoundExpression)
             Dim initialValue As BoundExpression = DirectCast(Me.Visit(node.InitialValue), BoundExpression)
-            Return node.Update(node.InitializedFields, memberAccessExpressionOpt, initialValue)
+            Return node.Update(node.InitializedFields, memberAccessExpressionOpt, initialValue, node.BinderOpt)
         End Function
 
         Public Overrides Function VisitPropertyInitializer(node As BoundPropertyInitializer) As BoundNode
             Dim memberAccessExpressionOpt As BoundExpression = DirectCast(Me.Visit(node.MemberAccessExpressionOpt), BoundExpression)
             Dim initialValue As BoundExpression = DirectCast(Me.Visit(node.InitialValue), BoundExpression)
-            Return node.Update(node.InitializedProperties, memberAccessExpressionOpt, initialValue)
+            Return node.Update(node.InitializedProperties, memberAccessExpressionOpt, initialValue, node.BinderOpt)
         End Function
 
         Public Overrides Function VisitParameterEqualsValue(node As BoundParameterEqualsValue) As BoundNode
@@ -13663,7 +13671,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Public Overrides Function VisitObjectInitializerExpression(node As BoundObjectInitializerExpression, arg As Object) As TreeDumperNode
             Return New TreeDumperNode("objectInitializerExpression", Nothing, New TreeDumperNode() {
                 New TreeDumperNode("createTemporaryLocalForInitialization", node.CreateTemporaryLocalForInitialization, Nothing),
-                New TreeDumperNode("binder", node.Binder, Nothing),
                 New TreeDumperNode("placeholderOpt", Nothing, new TreeDumperNode() {Visit(node.PlaceholderOpt, Nothing)}),
                 New TreeDumperNode("initializers", Nothing, From x In node.Initializers Select Visit(x, Nothing)),
                 New TreeDumperNode("type", node.Type, Nothing)
@@ -13786,7 +13793,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Public Overrides Function VisitAsNewLocalDeclarations(node As BoundAsNewLocalDeclarations, arg As Object) As TreeDumperNode
             Return New TreeDumperNode("asNewLocalDeclarations", Nothing, New TreeDumperNode() {
                 New TreeDumperNode("localDeclarations", Nothing, From x In node.LocalDeclarations Select Visit(x, Nothing)),
-                New TreeDumperNode("initializer", Nothing, new TreeDumperNode() {Visit(node.Initializer, Nothing)})
+                New TreeDumperNode("initializer", Nothing, new TreeDumperNode() {Visit(node.Initializer, Nothing)}),
+                New TreeDumperNode("binder", node.Binder, Nothing)
             })
         End Function
 
@@ -13805,7 +13813,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return New TreeDumperNode("fieldInitializer", Nothing, New TreeDumperNode() {
                 New TreeDumperNode("initializedFields", node.InitializedFields, Nothing),
                 New TreeDumperNode("memberAccessExpressionOpt", Nothing, new TreeDumperNode() {Visit(node.MemberAccessExpressionOpt, Nothing)}),
-                New TreeDumperNode("initialValue", Nothing, new TreeDumperNode() {Visit(node.InitialValue, Nothing)})
+                New TreeDumperNode("initialValue", Nothing, new TreeDumperNode() {Visit(node.InitialValue, Nothing)}),
+                New TreeDumperNode("binderOpt", node.BinderOpt, Nothing)
             })
         End Function
 
@@ -13813,7 +13822,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return New TreeDumperNode("propertyInitializer", Nothing, New TreeDumperNode() {
                 New TreeDumperNode("initializedProperties", node.InitializedProperties, Nothing),
                 New TreeDumperNode("memberAccessExpressionOpt", Nothing, new TreeDumperNode() {Visit(node.MemberAccessExpressionOpt, Nothing)}),
-                New TreeDumperNode("initialValue", Nothing, new TreeDumperNode() {Visit(node.InitialValue, Nothing)})
+                New TreeDumperNode("initialValue", Nothing, new TreeDumperNode() {Visit(node.InitialValue, Nothing)}),
+                New TreeDumperNode("binderOpt", node.BinderOpt, Nothing)
             })
         End Function
 
diff --git a/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_AsNewLocalDeclarations.vb b/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_AsNewLocalDeclarations.vb
index 7d0feb839fcdf..b4b23ed1b155f 100644
--- a/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_AsNewLocalDeclarations.vb
+++ b/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_AsNewLocalDeclarations.vb
@@ -16,27 +16,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Public Overrides Function VisitAsNewLocalDeclarations(node As BoundAsNewLocalDeclarations) As BoundNode
             Dim builder = ArrayBuilder(Of BoundStatement).GetInstance()
 
-            ' The initializer expression may contain placeholder values and typically they are replaced with bound locals that
-            ' get created in the local rewriter when rewriting the expression. 
-            ' 
-            ' There is one case where the placeholder does not get replaced by a bound temporary and needs to be replaced by
-            ' the currently declared local. This is the case for an object creation expression with a object initializer if it's
-            ' used in an AsNew declaration and the type is a value type, e.g.:
-            ' Dim x As New ValType() With {...} 
-            '     or
-            ' Dim x, y As New ValType() With {...} 
-            ' Because only this method knows the bound local that the placeholder will be replaced with, we need to fill 
-            ' the replacement map here, before rewriting the local declaration (there is a special case, because the first 
-            ' example will be bound to a BoundLocalDeclaration, see LocalRewriter.VisitLocalDeclaration for the special case).
-            '
-            Dim objectInitializer As BoundObjectInitializerExpression = GetBoundObjectInitializerFromInitializer(node.Initializer)
-
             Dim localDeclarations = node.LocalDeclarations
             For declarationIndex = 0 To localDeclarations.Length - 1
                 Dim localDeclaration = localDeclarations(declarationIndex)
                 Debug.Assert(localDeclaration.InitializerOpt Is Nothing)
 
-                Dim rewrittenInitializer As BoundNode = Nothing
+                Dim rewrittenInitializer As BoundNode
 
                 Dim localSymbol = localDeclaration.LocalSymbol
                 Dim staticLocalBackingFields As KeyValuePair(Of SynthesizedStaticLocalBackingField, SynthesizedStaticLocalBackingField) = Nothing
@@ -45,52 +30,61 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     staticLocalBackingFields = CreateBackingFieldsForStaticLocal(localSymbol, hasInitializer:=True)
                 End If
 
+                Dim initializerToRewrite As BoundExpression
+
+                If declarationIndex = 0 Then
+                    initializerToRewrite = node.Initializer
+                Else
+                    ' For all variables except the first one we rebind the initializer
+                    ' and throw away diagnostics, those are supposed to be reported in the first
+                    ' binding and don't need to be duplicated as Dev10/11 does
+                    '
+                    ' Note that we have to rebind the initializers because current implementation of lambda 
+                    ' rewriter does not handle correctly blocks and locals which are reused in bound tree. 
+                    ' Actually it seems to heavily rely on an assumption that the bound tree is a tree, not 
+                    ' a DAG, with just minor deviations. Thus, the natural way of just rewriting bound 
+                    ' initializer stored in node.Initializer simply does not work because rewriting *may* 
+                    ' keep many blocks and locals unchanged and reuse them in all rewritten initializers, 
+                    ' in which case if we have a lambda inside the initializer lambda rewriter simply throws.
+                    '
+                    ' Another option to satisfy lambda rewriter would be to deep-clone bound tree, but 
+                    ' in this case we will also have to clone all locals and all references to locals.
+                    ' We might want to look into this option later.
+
+                    Debug.Assert(node.Syntax IsNot Nothing)
+                    Debug.Assert(node.Syntax.Kind = SyntaxKind.VariableDeclarator)
+
+                    Dim varDecl = DirectCast(node.Syntax, VariableDeclaratorSyntax)
+                    Dim asNew = DirectCast(varDecl.AsClause, AsNewClauseSyntax)
+
+                    ' Rebind and discard diagnostics
+                    initializerToRewrite = node.Binder.BindVariableDeclaration(varDecl, varDecl.Names(declarationIndex), asNew, Nothing, BindingDiagnosticBag.Discarded, skipAsNewInitializer:=False).InitializerOpt
+                End If
+
+                ' The initializer expression may contain placeholder values and typically they are replaced with bound locals that
+                ' get created in the local rewriter when rewriting the expression. 
+                ' 
+                ' There is one case where the placeholder does not get replaced by a bound temporary and needs to be replaced by
+                ' the currently declared local. This is the case for an object creation expression with a object initializer if it's
+                ' used in an AsNew declaration and the type is a value type, e.g.:
+                ' Dim x As New ValType() With {...} 
+                '     or
+                ' Dim x, y As New ValType() With {...} 
+                ' Because only this method knows the bound local that the placeholder will be replaced with, we need to fill 
+                ' the replacement map here, before rewriting the local declaration (there is a special case, because the first 
+                ' example will be bound to a BoundLocalDeclaration, see LocalRewriter.VisitLocalDeclaration for the special case).
+                '
+                Dim objectInitializer As BoundObjectInitializerExpression = GetBoundObjectInitializerFromInitializer(initializerToRewrite)
+
+
                 ' rewrite the initializer for each declared variable because the initializer may contain placeholders that need
                 ' to be replaced with the current bound local
+
                 If objectInitializer IsNot Nothing Then
                     Debug.Assert(objectInitializer.PlaceholderOpt IsNot Nothing)
 
-                    Dim initializerToRewrite As BoundExpression = node.Initializer
                     Dim placeholder As BoundWithLValueExpressionPlaceholder = objectInitializer.PlaceholderOpt
 
-                    If declarationIndex > 0 Then
-
-                        ' For all variables except the first one we rebind the initializer
-                        ' and throw away diagnostics, those are supposed to be reported in the first
-                        ' binding and don't need to be duplicated as Dev10/11 does
-                        '
-                        ' Note that we have to rebind the initializers because current implementation of lambda 
-                        ' rewriter does not handle correctly blocks and locals which are reused in bound tree. 
-                        ' Actually it seems to heavily rely on an assumption that the bound tree is a tree, not 
-                        ' a DAG, with just minor deviations. Thus, the natural way of just rewriting bound 
-                        ' initializer stored in node.Initializer simply does not work because rewriting *may* 
-                        ' keep many blocks and locals unchanged and reuse them in all rewritten initializers, 
-                        ' in which case if we have a lambda inside the initializer lambda rewriter simply throws.
-                        '
-                        ' Another option to satisfy lambda rewriter would be to deep-clone bound tree, but 
-                        ' in this case we will also have to clone all locals and all references to locals.
-                        ' We might want to look into this option later.
-
-                        Debug.Assert(node.Syntax IsNot Nothing)
-                        Debug.Assert(node.Syntax.Kind = SyntaxKind.VariableDeclarator)
-                        Dim asNew = DirectCast(DirectCast(node.Syntax, VariableDeclaratorSyntax).AsClause, AsNewClauseSyntax)
-
-                        Dim objectCreationExpressionSyntax = DirectCast(asNew.NewExpression, ObjectCreationExpressionSyntax)
-                        Dim localType As TypeSymbol = localSymbol.Type
-
-                        ' New placeholder
-                        placeholder = New BoundWithLValueExpressionPlaceholder(asNew, localType)
-                        placeholder.SetWasCompilerGenerated()
-
-                        ' Rebind and discard diagnostics
-                        initializerToRewrite = objectInitializer.Binder.BindObjectCreationExpression(asNew.Type,
-                                                                                                     objectCreationExpressionSyntax.ArgumentList,
-                                                                                                     localType,
-                                                                                                     objectCreationExpressionSyntax,
-                                                                                                     BindingDiagnosticBag.Discarded,
-                                                                                                     placeholder)
-                    End If
-
                     If Not objectInitializer.CreateTemporaryLocalForInitialization Then
                         AddPlaceholderReplacement(placeholder,
                                                   VisitExpressionNode(New BoundLocal(localDeclaration.Syntax,
@@ -105,7 +99,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     End If
 
                 Else
-                    rewrittenInitializer = Me.VisitAndGenerateObjectCloneIfNeeded(node.Initializer)
+                    rewrittenInitializer = Me.VisitAndGenerateObjectCloneIfNeeded(initializerToRewrite)
                 End If
 
                 Dim initialization = RewriteLocalDeclarationAsInitializer(
diff --git a/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_FieldOrPropertyInitializer.vb b/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_FieldOrPropertyInitializer.vb
index 810ac06c4cd48..6ff410c45917a 100644
--- a/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_FieldOrPropertyInitializer.vb
+++ b/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_FieldOrPropertyInitializer.vb
@@ -54,23 +54,50 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 meReferenceOpt.SetWasCompilerGenerated()
             End If
 
-            Dim objectInitializer As BoundObjectInitializerExpression = Nothing
-            Dim createTemporary = True
-            If node.InitialValue.Kind = BoundKind.ObjectCreationExpression OrElse node.InitialValue.Kind = BoundKind.NewT Then
-                Dim objectCreationExpression = DirectCast(node.InitialValue, BoundObjectCreationExpressionBase)
-                If objectCreationExpression.InitializerOpt IsNot Nothing AndAlso
-                    objectCreationExpression.InitializerOpt.Kind = BoundKind.ObjectInitializerExpression Then
-                    objectInitializer = DirectCast(objectCreationExpression.InitializerOpt, BoundObjectInitializerExpression)
-                    createTemporary = objectInitializer.CreateTemporaryLocalForInitialization
-                End If
-            End If
-
             Dim instrument As Boolean = Me.Instrument(node)
 
             For symbolIndex = 0 To initializedSymbols.Length - 1
                 Dim symbol = initializedSymbols(symbolIndex)
                 Dim accessExpression As BoundExpression
 
+                Dim initialValueToRewrite As BoundExpression
+
+                If symbolIndex = 0 Then
+                    initialValueToRewrite = node.InitialValue
+                Else
+                    ' For all variables except the first one we rebind the initializer
+                    ' and throw away diagnostics, those are supposed to be reported in the first
+                    ' binding and don't need to be duplicated
+                    '
+                    ' Note that we have to rebind the initializers because current implementation of lambda 
+                    ' rewriter does not handle correctly blocks and locals which are reused in bound tree. 
+                    ' Actually it seems to heavily rely on an assumption that the bound tree is a tree, not 
+                    ' a DAG, with just minor deviations. Thus, the natural way of just rewriting bound 
+                    ' initializer stored in node.Initializer simply does not work because rewriting *may* 
+                    ' keep many blocks and locals unchanged and reuse them in all rewritten initializers, 
+                    ' in which case if we have a lambda inside the initializer lambda rewriter simply throws.
+
+                    If symbol.Kind = SymbolKind.Field Then
+                        ' Rebind and discard diagnostics
+                        initialValueToRewrite = node.BinderOpt.BindFieldInitializerExpression(syntax, DirectCast(symbol, FieldSymbol), BindingDiagnosticBag.Discarded)
+                    Else
+                        ' Rebind and discard diagnostics
+                        initialValueToRewrite = node.BinderOpt.BindPropertyInitializerExpression(syntax, DirectCast(symbol, PropertySymbol), BindingDiagnosticBag.Discarded)
+                    End If
+                End If
+
+                Dim objectInitializer As BoundObjectInitializerExpression = Nothing
+                Dim createTemporary = True
+
+                If initialValueToRewrite.Kind = BoundKind.ObjectCreationExpression OrElse initialValueToRewrite.Kind = BoundKind.NewT Then
+                    Dim objectCreationExpression = DirectCast(initialValueToRewrite, BoundObjectCreationExpressionBase)
+                    If objectCreationExpression.InitializerOpt IsNot Nothing AndAlso
+                    objectCreationExpression.InitializerOpt.Kind = BoundKind.ObjectInitializerExpression Then
+                        objectInitializer = DirectCast(objectCreationExpression.InitializerOpt, BoundObjectInitializerExpression)
+                        createTemporary = objectInitializer.CreateTemporaryLocalForInitialization
+                    End If
+                End If
+
                 ' if there are more than one symbol we need to create a field or property access for each of them
                 If initializedSymbols.Length > 1 Then
                     If symbol.Kind = SymbolKind.Field Then
@@ -102,14 +129,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     ' we need to replace the placeholder with it, so add it to the replacement map
                     AddPlaceholderReplacement(objectInitializer.PlaceholderOpt, accessExpression)
 
-                    rewrittenStatement = VisitExpressionNode(node.InitialValue).ToStatement
+                    rewrittenStatement = VisitExpressionNode(initialValueToRewrite).ToStatement
 
                     RemovePlaceholderReplacement(objectInitializer.PlaceholderOpt)
                 Else
                     ' in all other cases we want the initial value be assigned to the member (field or property)
                     rewrittenStatement = VisitExpression(New BoundAssignmentOperator(syntax,
                                                                                      accessExpression,
-                                                                                     node.InitialValue,
+                                                                                     initialValueToRewrite,
                                                                                      suppressObjectClone:=False)).ToStatement
                 End If
 
diff --git a/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreation.vb b/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreation.vb
index 2997b04509a1a..3dfbba5c3e195 100644
--- a/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreation.vb
+++ b/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreation.vb
@@ -388,7 +388,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Return ReplaceObjectOrCollectionInitializer(
                             rewrittenObjectCreationExpression,
                             node.Update(node.CreateTemporaryLocalForInitialization,
-                                        node.Binder,
                                         node.PlaceholderOpt,
                                         newInitializers.AsImmutableOrNull(),
                                         node.Type))
diff --git a/src/Compilers/VisualBasic/Portable/Lowering/MethodToClassRewriter/MethodToClassRewriter.vb b/src/Compilers/VisualBasic/Portable/Lowering/MethodToClassRewriter/MethodToClassRewriter.vb
index 79265b51e293d..d0eb4b39bfa31 100644
--- a/src/Compilers/VisualBasic/Portable/Lowering/MethodToClassRewriter/MethodToClassRewriter.vb
+++ b/src/Compilers/VisualBasic/Portable/Lowering/MethodToClassRewriter/MethodToClassRewriter.vb
@@ -26,13 +26,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' A mapping from every local variable to its replacement local variable. Local variables 
         ''' are replaced when their types change due to being inside of a lambda within a generic method.
         ''' </summary>
-        Protected ReadOnly LocalMap As Dictionary(Of LocalSymbol, LocalSymbol) = New Dictionary(Of LocalSymbol, LocalSymbol)()
+        Protected ReadOnly LocalMap As Dictionary(Of LocalSymbol, LocalSymbol) = New Dictionary(Of LocalSymbol, LocalSymbol)(ReferenceEqualityComparer.Instance)
 
         ''' <summary>
         ''' A mapping from every parameter to its replacement parameter. Local variables 
         ''' are replaced when their types change due to being inside of a lambda.
         ''' </summary>
-        Protected ReadOnly ParameterMap As Dictionary(Of ParameterSymbol, ParameterSymbol) = New Dictionary(Of ParameterSymbol, ParameterSymbol)()
+        Protected ReadOnly ParameterMap As Dictionary(Of ParameterSymbol, ParameterSymbol) = New Dictionary(Of ParameterSymbol, ParameterSymbol)(ReferenceEqualityComparer.Instance)
 
         Protected ReadOnly PlaceholderReplacementMap As New Dictionary(Of BoundValuePlaceholderBase, BoundExpression)
 
diff --git a/src/Compilers/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.vbproj b/src/Compilers/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.vbproj
index 840b7ecd76e75..a4e3694d5dca4 100644
--- a/src/Compilers/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.vbproj
+++ b/src/Compilers/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.vbproj
@@ -8,7 +8,7 @@
     <CodeAnalysisRuleSet>..\BasicCodeAnalysisRules.ruleset</CodeAnalysisRuleSet>
     <GenerateMicrosoftCodeAnalysisCommitHashAttribute>true</GenerateMicrosoftCodeAnalysisCommitHashAttribute>
     <RootNamespace></RootNamespace>
-    <ApplyNgenOptimization>partial</ApplyNgenOptimization>
+    <ApplyNgenOptimization Condition="'$(TargetFramework)' == 'netstandard2.0'">partial</ApplyNgenOptimization>
 
     <!-- NuGet -->
     <IsPackable>true</IsPackable>
diff --git a/src/Compilers/VisualBasic/Portable/SourceGeneration/VisualBasicGeneratorDriver.vb b/src/Compilers/VisualBasic/Portable/SourceGeneration/VisualBasicGeneratorDriver.vb
index d8ad0c0932ccf..3c4cd057ef2f8 100644
--- a/src/Compilers/VisualBasic/Portable/SourceGeneration/VisualBasicGeneratorDriver.vb
+++ b/src/Compilers/VisualBasic/Portable/SourceGeneration/VisualBasicGeneratorDriver.vb
@@ -16,7 +16,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         End Sub
 
         Friend Sub New(parseOptions As VisualBasicParseOptions, generators As ImmutableArray(Of ISourceGenerator), optionsProvider As AnalyzerConfigOptionsProvider, additionalTexts As ImmutableArray(Of AdditionalText))
-            MyBase.New(parseOptions, generators, optionsProvider, additionalTexts)
+            MyBase.New(parseOptions, generators, optionsProvider, additionalTexts, enableIncremental:=False)
         End Sub
 
         Friend Overrides ReadOnly Property MessageProvider As CommonMessageProvider
@@ -34,7 +34,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         End Function
 
         Public Shared Function Create(generators As ImmutableArray(Of ISourceGenerator), Optional additionalTexts As ImmutableArray(Of AdditionalText) = Nothing, Optional parseOptions As VisualBasicParseOptions = Nothing, Optional analyzerConfigOptionsProvider As AnalyzerConfigOptionsProvider = Nothing) As VisualBasicGeneratorDriver
-            Return New VisualBasicGeneratorDriver(parseOptions, generators, analyzerConfigOptionsProvider, additionalTexts)
+            Return New VisualBasicGeneratorDriver(parseOptions, generators, If(analyzerConfigOptionsProvider, CompilerAnalyzerConfigOptionsProvider.Empty), additionalTexts.NullToEmpty())
         End Function
 
         Friend Overrides Function CreateSourcesCollection() As AdditionalSourcesCollection
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/MemberRefMetadataDecoder.vb b/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/MemberRefMetadataDecoder.vb
index a1dee50b3df56..3e3985ba83fea 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/MemberRefMetadataDecoder.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/MemberRefMetadataDecoder.vb
@@ -43,35 +43,22 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
         End Function
 
         ''' <summary>
-        ''' This override changes two things:
-        '''     1) Return type arguments instead of type parameters.
-        '''     2) Handle non-PE types.
+        ''' This override can handle non-PE types.
         ''' </summary>
         Protected Overrides Function GetGenericTypeParamSymbol(position As Integer) As TypeSymbol
             Dim peType As PENamedTypeSymbol = TryCast(Me._containingType, PENamedTypeSymbol)
             If peType IsNot Nothing Then
-                While peType IsNot Nothing AndAlso (peType.MetadataArity - peType.Arity) > position
-                    peType = TryCast(peType.ContainingSymbol, PENamedTypeSymbol)
-                End While
-
-                If peType Is Nothing OrElse peType.MetadataArity <= position Then
-                    Return New UnsupportedMetadataTypeSymbol(VBResources.PositionOfTypeParameterTooLarge)
-                End If
-
-                position -= peType.MetadataArity - peType.Arity
-                Debug.Assert(position >= 0 AndAlso position < peType.Arity)
-
-                Return peType.TypeArgumentsNoUseSiteDiagnostics(position)
+                Return MyBase.GetGenericTypeParamSymbol(position)
             End If
 
             Dim namedType As NamedTypeSymbol = TryCast(Me._containingType, NamedTypeSymbol)
             If namedType IsNot Nothing Then
                 Dim cumulativeArity As Integer
-                Dim typeArgument As TypeSymbol = Nothing
+                Dim typeParameter As TypeParameterSymbol = Nothing
 
-                GetGenericTypeArgumentSymbol(position, namedType, cumulativeArity, typeArgument)
-                If typeArgument IsNot Nothing Then
-                    Return typeArgument
+                GetGenericTypeParameterSymbol(position, namedType, cumulativeArity, typeParameter)
+                If typeParameter IsNot Nothing Then
+                    Return typeParameter
                 Else
                     Debug.Assert(cumulativeArity <= position)
                     Return New UnsupportedMetadataTypeSymbol(VBResources.PositionOfTypeParameterTooLarge)
@@ -81,7 +68,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
             Return New UnsupportedMetadataTypeSymbol(VBResources.AssociatedTypeDoesNotHaveTypeParameters)
         End Function
 
-        Private Shared Sub GetGenericTypeArgumentSymbol(position As Integer, namedType As NamedTypeSymbol, ByRef cumulativeArity As Integer, ByRef typeArgument As TypeSymbol)
+        Private Shared Sub GetGenericTypeParameterSymbol(position As Integer, namedType As NamedTypeSymbol, ByRef cumulativeArity As Integer, ByRef typeArgument As TypeParameterSymbol)
             cumulativeArity = namedType.Arity
             typeArgument = Nothing
 
@@ -91,29 +78,24 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
             If containingType IsNot Nothing Then
                 Dim containingTypeCumulativeArity As Integer
 
-                GetGenericTypeArgumentSymbol(position, containingType, containingTypeCumulativeArity, typeArgument)
+                GetGenericTypeParameterSymbol(position, containingType, containingTypeCumulativeArity, typeArgument)
                 cumulativeArity += containingTypeCumulativeArity
                 arityOffset = containingTypeCumulativeArity
             End If
 
             If arityOffset <= position AndAlso position < cumulativeArity Then
                 Debug.Assert(typeArgument Is Nothing)
-                typeArgument = namedType.TypeArgumentsNoUseSiteDiagnostics(position - arityOffset)
+                typeArgument = namedType.TypeParameters(position - arityOffset)
             End If
         End Sub
 
         ''' <summary> 
-        ''' Search through the members of a given type symbol to find the method that matches a particular signature. 
+        ''' Search through the members of the <see cref="_containingType"/> type symbol to find the method that matches a particular signature. 
         ''' </summary> 
-        ''' <param name="targetTypeSymbol">Type containing the desired method symbol.</param> 
         ''' <param name="memberRef">A MemberRef handle that can be used to obtain the name and signature of the method</param> 
         ''' <param name="methodsOnly">True to only return a method.</param> 
         ''' <returns>The matching method symbol, or null if the inputs do not correspond to a valid method.</returns>
-        Friend Function FindMember(targetTypeSymbol As TypeSymbol, memberRef As MemberReferenceHandle, methodsOnly As Boolean) As Symbol
-            If targetTypeSymbol Is Nothing Then
-                Return Nothing
-            End If
-
+        Friend Function FindMember(memberRef As MemberReferenceHandle, methodsOnly As Boolean) As Symbol
             Try
                 Dim memberName As String = [Module].GetMemberRefNameOrThrow(memberRef)
                 Dim signatureHandle = [Module].GetSignatureOrThrow(memberRef)
@@ -124,7 +106,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
                     Case SignatureCallingConvention.Default, SignatureCallingConvention.VarArgs
                         Dim typeParamCount As Integer
                         Dim targetParamInfo As ParamInfo(Of TypeSymbol)() = Me.DecodeSignatureParametersOrThrow(signaturePointer, signatureHeader, typeParamCount)
-                        Return FindMethodBySignature(targetTypeSymbol, memberName, signatureHeader, typeParamCount, targetParamInfo)
+                        Return FindMethodBySignature(_containingType, memberName, signatureHeader, typeParamCount, targetParamInfo)
 
                     Case SignatureKind.Field
                         If methodsOnly Then
@@ -134,7 +116,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
 
                         Dim customModifiers As ImmutableArray(Of ModifierInfo(Of TypeSymbol)) = Nothing
                         Dim type As TypeSymbol = Me.DecodeFieldSignature(signaturePointer, customModifiers)
-                        Return FindFieldBySignature(targetTypeSymbol, memberName, customModifiers, type)
+                        Return FindFieldBySignature(_containingType, memberName, customModifiers, type)
 
                     Case Else
                         ' error
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/MetadataDecoder.vb b/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/MetadataDecoder.vb
index 012387b04a03d..b5c1a53d2eada 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/MetadataDecoder.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/MetadataDecoder.vb
@@ -458,8 +458,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
 
             ' We're going to use a special decoder that can generate usable symbols for type parameters without full context.
             ' (We're not just using a different type - we're also changing the type context.)
-            Dim memberRefDecoder = New MemberRefMetadataDecoder(moduleSymbol, targetTypeSymbol)
-            Return memberRefDecoder.FindMember(targetTypeSymbol, memberRef, methodsOnly)
+            Dim memberRefDecoder = New MemberRefMetadataDecoder(moduleSymbol, targetTypeSymbol.OriginalDefinition)
+
+            Dim definition = memberRefDecoder.FindMember(memberRef, methodsOnly)
+
+            If definition IsNot Nothing AndAlso Not targetTypeSymbol.IsDefinition Then
+                Return definition.AsMember(DirectCast(targetTypeSymbol, NamedTypeSymbol))
+            End If
+
+            Return definition
         End Function
 
         Protected Overrides Sub EnqueueTypeSymbolInterfacesAndBaseTypes(typeDefsToSearch As Queue(Of TypeDefinitionHandle), typeSymbolsToSearch As Queue(Of TypeSymbol), typeSymbol As TypeSymbol)
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb
index 02e4d5e75dc07..8d6930537561a 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb
@@ -1187,7 +1187,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
 
             Try
                 For Each methodDef In [module].GetMethodsOfTypeOrThrow(_handle)
-                    If [module].ShouldImportMethod(methodDef, moduleSymbol.ImportOptions) Then
+                    If [module].ShouldImportMethod(_handle, methodDef, moduleSymbol.ImportOptions) Then
                         methods.Add(methodDef, New PEMethodSymbol(moduleSymbol, Me, methodDef))
                     End If
                 Next
@@ -1207,8 +1207,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
                         Dim methods = [module].GetPropertyMethodsOrThrow(propertyDef)
 
 
-                        Dim getMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, methods.Getter)
-                        Dim setMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, methods.Setter)
+                        Dim getMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, _handle, methods.Getter)
+                        Dim setMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, _handle, methods.Setter)
 
                         If (getMethod IsNot Nothing) OrElse (setMethod IsNot Nothing) Then
                             members.Add(PEPropertySymbol.Create(moduleSymbol, Me, propertyDef, getMethod, setMethod))
@@ -1230,9 +1230,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
                         Dim methods = [module].GetEventMethodsOrThrow(eventRid)
 
                         ' NOTE: C# ignores all other accessors (most notably, raise/fire).
-                        Dim addMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, methods.Adder)
-                        Dim removeMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, methods.Remover)
-                        Dim raiseMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, methods.Raiser)
+                        Dim addMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, _handle, methods.Adder)
+                        Dim removeMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, _handle, methods.Remover)
+                        Dim raiseMethod = GetAccessorMethod(moduleSymbol, methodHandleToSymbol, _handle, methods.Raiser)
 
                         ' VB ignores events that do not have both Add and Remove.
                         If (addMethod IsNot Nothing) AndAlso (removeMethod IsNot Nothing) Then
@@ -1245,14 +1245,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
             End Try
         End Sub
 
-        Private Shared Function GetAccessorMethod(moduleSymbol As PEModuleSymbol, methodHandleToSymbol As Dictionary(Of MethodDefinitionHandle, PEMethodSymbol), methodDef As MethodDefinitionHandle) As PEMethodSymbol
+        Private Shared Function GetAccessorMethod(moduleSymbol As PEModuleSymbol, methodHandleToSymbol As Dictionary(Of MethodDefinitionHandle, PEMethodSymbol), typeDef As TypeDefinitionHandle, methodDef As MethodDefinitionHandle) As PEMethodSymbol
             If methodDef.IsNil Then
                 Return Nothing
             End If
 
             Dim method As PEMethodSymbol = Nothing
             Dim found As Boolean = methodHandleToSymbol.TryGetValue(methodDef, method)
-            Debug.Assert(found OrElse Not moduleSymbol.Module.ShouldImportMethod(methodDef, moduleSymbol.ImportOptions))
+            Debug.Assert(found OrElse Not moduleSymbol.Module.ShouldImportMethod(typeDef, methodDef, moduleSymbol.ImportOptions))
             Return method
         End Function
 
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Retargeting/RetargetingSymbolTranslator.vb b/src/Compilers/VisualBasic/Portable/Symbols/Retargeting/RetargetingSymbolTranslator.vb
index 59ce74a4b4a2c..46e7c7e6a1bb2 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Retargeting/RetargetingSymbolTranslator.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Retargeting/RetargetingSymbolTranslator.vb
@@ -884,6 +884,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Retargeting
             End Function
 
             Public Function Retarget(method As MethodSymbol, retargetedMethodComparer As IEqualityComparer(Of MethodSymbol)) As MethodSymbol
+                Debug.Assert(method Is method.ConstructedFrom)
+
                 If method.ContainingModule Is Me.UnderlyingModule AndAlso method.IsDefinition Then
                     Return DirectCast(SymbolMap.GetOrAdd(method, _retargetingModule._createRetargetingMethod), RetargetingMethodSymbol)
                 End If
@@ -891,10 +893,26 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Retargeting
                 Dim containingType = method.ContainingType
                 Dim retargetedType = Retarget(containingType, RetargetOptions.RetargetPrimitiveTypesByName)
 
+                If retargetedType Is containingType Then
+                    Return method
+                End If
+
+                If Not containingType.IsDefinition Then
+                    Debug.Assert(Not retargetedType.IsDefinition)
+
+                    Dim retargetedDefinition = Retarget(method.OriginalDefinition, retargetedMethodComparer)
+
+                    If retargetedDefinition Is Nothing Then
+                        Return Nothing
+                    End If
+
+                    Return retargetedDefinition.AsMember(retargetedType)
+                End If
+
+                Debug.Assert(retargetedType.IsDefinition)
+
                 ' NB: may return null if the method cannot be found in the retargeted type (e.g. removed in a subsequent version)
-                Return If(retargetedType Is containingType,
-                          method,
-                          FindMethodInRetargetedType(method, retargetedType, retargetedMethodComparer))
+                Return FindMethodInRetargetedType(method, retargetedType, retargetedMethodComparer)
             End Function
 
             Private Function FindMethodInRetargetedType(method As MethodSymbol, retargetedType As NamedTypeSymbol, retargetedMethodComparer As IEqualityComparer(Of MethodSymbol)) As MethodSymbol
@@ -904,8 +922,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Retargeting
             Private Class RetargetedTypeMethodFinder
                 Inherits RetargetingSymbolTranslator
 
-                Private Sub New(retargetingModule As RetargetingModuleSymbol)
+                Private ReadOnly _retargetedType As NamedTypeSymbol
+                Private ReadOnly _toFind As MethodSymbol
+
+                Private Sub New(retargetingModule As RetargetingModuleSymbol, retargetedType As NamedTypeSymbol, toFind As MethodSymbol)
                     MyBase.New(retargetingModule)
+
+                    _retargetedType = retargetedType
+                    _toFind = toFind
                 End Sub
 
                 Public Shared Function Find(
@@ -918,7 +942,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Retargeting
                         Return Nothing
                     End If
 
-                    If Not method.IsGenericMethod Then
+                    If Not method.IsGenericMethod AndAlso Not retargetedType.IsGenericType Then
                         Return FindWorker(translator, method, retargetedType, retargetedMethodComparer)
                     End If
 
@@ -926,9 +950,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Retargeting
                     ' among members of a type, constructed methods are never returned through GetMembers API.
                     Debug.Assert(method Is method.ConstructedFrom)
 
-                    ' A generic method needs special handling because its signature is very likely
-                    ' to refer to method's type parameters.
-                    Dim finder = New RetargetedTypeMethodFinder(translator._retargetingModule)
+                    ' A generic method or a method in generic type needs special handling because its signature is very likely
+                    ' to refer to method's or type's type parameters.
+                    Dim finder = New RetargetedTypeMethodFinder(translator._retargetingModule, retargetedType, method)
                     Return FindWorker(finder, method, retargetedType, retargetedMethodComparer)
                 End Function
 
@@ -977,15 +1001,27 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Retargeting
                 End Function
 
                 Public Overrides Function Retarget(typeParameter As TypeParameterSymbol) As TypeParameterSymbol
-                    If typeParameter.ContainingModule Is Me.UnderlyingModule Then
-                        Return MyBase.Retarget(typeParameter)
+                    If typeParameter.TypeParameterKind = TypeParameterKind.Method Then
+                        Debug.Assert(typeParameter.ContainingSymbol Is _toFind)
+
+                        ' The method symbol we are building will be using IndexedTypeParameterSymbols as 
+                        ' its type parameters, therefore, we should return them here as well.
+                        Return IndexedTypeParameterSymbol.GetTypeParameter(typeParameter.Ordinal)
                     End If
 
-                    Debug.Assert(typeParameter.TypeParameterKind = TypeParameterKind.Method)
+                    Dim containingType As NamedTypeSymbol = _toFind.ContainingType
+                    Dim retargetedContainingType As NamedTypeSymbol = _retargetedType
+
+                    Do
+                        If containingType Is typeParameter.ContainingSymbol Then
+                            Return retargetedContainingType.TypeParameters(typeParameter.Ordinal)
+                        End If
+
+                        containingType = containingType.ContainingType
+                        retargetedContainingType = retargetedContainingType.ContainingType
+                    Loop While containingType IsNot Nothing
 
-                    ' The method symbol we are building will be using IndexedTypeParameterSymbols as 
-                    ' its type parameters, therefore, we should return them here as well.
-                    Return IndexedTypeParameterSymbol.GetTypeParameter(typeParameter.Ordinal)
+                    Throw ExceptionUtilities.Unreachable
                 End Function
             End Class
 
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/SynthesizedSymbols/SynthesizedClonedTypeParameterSymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/SynthesizedSymbols/SynthesizedClonedTypeParameterSymbol.vb
index 85122d83b1244..d7a9a545059da 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/SynthesizedSymbols/SynthesizedClonedTypeParameterSymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/SynthesizedSymbols/SynthesizedClonedTypeParameterSymbol.vb
@@ -45,6 +45,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             _correspondingMethodTypeParameter = correspondingMethodTypeParameter
             _name = name
             _typeMapFactory = typeMapFactory
+
+            Debug.Assert(Me.TypeParameterKind = If(TypeOf Me.ContainingSymbol Is MethodSymbol, TypeParameterKind.Method,
+                                                If(TypeOf Me.ContainingSymbol Is NamedTypeSymbol, TypeParameterKind.Type,
+                                                TypeParameterKind.Cref)),
+                $"Container is {Me.ContainingSymbol?.Kind}, TypeParameterKind is {Me.TypeParameterKind}")
         End Sub
 
         Public Overrides ReadOnly Property TypeParameterKind As TypeParameterKind
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Wrapped/WrappedTypeParameterSymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/Wrapped/WrappedTypeParameterSymbol.vb
index c9cc775bfcd3d..a98e82937f542 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Wrapped/WrappedTypeParameterSymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Wrapped/WrappedTypeParameterSymbol.vb
@@ -88,6 +88,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
         Public Sub New(underlyingTypeParameter As TypeParameterSymbol)
             Debug.Assert(underlyingTypeParameter IsNot Nothing)
             Me._underlyingTypeParameter = underlyingTypeParameter
+
+            Debug.Assert(Me.TypeParameterKind = If(TypeOf Me.ContainingSymbol Is MethodSymbol, TypeParameterKind.Method,
+                                                If(TypeOf Me.ContainingSymbol Is NamedTypeSymbol, TypeParameterKind.Type,
+                                                TypeParameterKind.Cref)),
+                $"Container is {Me.ContainingSymbol?.Kind}, TypeParameterKind is {Me.TypeParameterKind}")
         End Sub
 
         Public Overrides Function GetDocumentationCommentXml(Optional preferredCulture As CultureInfo = Nothing, Optional expandIncludes As Boolean = False, Optional cancellationToken As CancellationToken = Nothing) As String
diff --git a/src/Compilers/VisualBasic/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.vb b/src/Compilers/VisualBasic/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.vb
index 8de7ec862a34c..b18da30f4d268 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.vb
@@ -2309,4 +2309,105 @@ BC37254: Public sign was specified and requires a public key, but no public key
 </errors>)
     End Sub
 
+    <Theory>
+    <MemberData(NameOf(AllProviderParseOptions))>
+    <WorkItem(1341051, "https://dev.azure.com/devdiv/DevDiv/_workitems/edit/1341051")>
+    Public Sub IVT_Circularity(parseOptions As VisualBasicParseOptions)
+        Dim other As VisualBasicCompilation = CreateCompilation(
+<compilation name="HasIVTToCompilation">
+    <file name="a.vb"><![CDATA[
+<Assembly: System.Runtime.CompilerServices.InternalsVisibleTo("WantsIVTAccess")>
+Public MustInherit Class TestBaseClass
+    Friend Overridable ReadOnly Property SupportSvgImages As Object
+        Get
+            Return True
+        End Get
+    End Property
+End Class
+]]>
+    </file>
+</compilation>, options:=TestOptions.SigningReleaseDll, parseOptions:=parseOptions)
+
+        other.VerifyDiagnostics()
+
+        Dim c2 As VisualBasicCompilation = CreateCompilation(
+<compilation name="WantsIVTAccess">
+    <file name="a.vb"><![CDATA[
+Public Class Class1
+    Inherits TestBaseClass
+
+    Friend Overrides ReadOnly Property SupportSvgImages As Object
+        Get
+            Return True
+        End Get
+    End Property
+End Class
+]]>
+    </file>
+    <file name="b.vb"><![CDATA[
+<assembly: Class1>
+]]>
+    </file>
+</compilation>, {New VisualBasicCompilationReference(other)}, options:=TestOptions.SigningReleaseDll, parseOptions:=parseOptions)
+
+        c2.AssertTheseDiagnostics(<error><![CDATA[
+BC31504: 'Class1' cannot be used as an attribute because it does not inherit from 'System.Attribute'.
+<assembly: Class1>
+           ~~~~~~
+]]></error>)
+    End Sub
+
+    <Theory>
+    <MemberData(NameOf(AllProviderParseOptions))>
+    <WorkItem(1341051, "https://dev.azure.com/devdiv/DevDiv/_workitems/edit/1341051")>
+    Public Sub IVT_Circularity_AttributeReferencesProperty(parseOptions As VisualBasicParseOptions)
+        Dim other As VisualBasicCompilation = CreateCompilation(
+<compilation name="HasIVTToCompilation">
+    <file name="a.vb"><![CDATA[
+<Assembly: System.Runtime.CompilerServices.InternalsVisibleTo("WantsIVTAccess")>
+Public MustInherit Class TestBaseClass
+    Friend Overridable ReadOnly Property SupportSvgImages As Object
+        Get
+            Return True
+        End Get
+    End Property
+End Class
+
+Public Class MyAttribute
+    Inherits System.Attribute
+
+    Public Sub New(s As String)
+    End Sub
+End Class
+]]>
+    </file>
+</compilation>, options:=TestOptions.SigningReleaseDll, parseOptions:=parseOptions)
+
+        other.VerifyDiagnostics()
+
+        Dim c2 As VisualBasicCompilation = CreateCompilation(
+<compilation name="WantsIVTAccess">
+    <file name="a.vb"><![CDATA[
+Public Class Class1
+    Inherits TestBaseClass
+
+    Friend Const Constant As String = "text"
+
+    Friend Overrides ReadOnly Property SupportSvgImages As Object
+        Get
+            Return True
+        End Get
+    End Property
+End Class
+]]>
+    </file>
+    <file name="b.vb"><![CDATA[
+<assembly: MyAttribute(Class1.Constant)>
+]]>
+    </file>
+</compilation>, {New VisualBasicCompilationReference(other)}, options:=TestOptions.SigningReleaseDll, parseOptions:=parseOptions)
+
+        c2.AssertNoDiagnostics()
+    End Sub
+
 End Class
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueClosureTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueClosureTests.vb
index 1e1e3abbe0b7d..d1a70a3446e3e 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueClosureTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueClosureTests.vb
@@ -222,7 +222,7 @@ End Class
                 Row(4, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                 Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
         End Sub
 
         <Fact>
@@ -435,9 +435,9 @@ End Module
                 Row(7, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                 Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
                 Row(11, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                Row(18, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(19, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                Row(20, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
         End Sub
 
         <WorkItem(1067140, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1067140")>
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.vb
index 49aca9d89d25c..fc4bd161e65f5 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.vb
@@ -911,7 +911,8 @@ End Class
                 Using md1 = diff1.GetMetadata()
                     CheckEncLogDefinitions(md1.Reader,
                         Row(3, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
-                        Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default))
+                        Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
             End Using
         End Sub
@@ -958,7 +959,9 @@ End Class
                 Using md1 = diff1.GetMetadata()
                     CheckEncLogDefinitions(md1.Reader,
                         Row(3, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
-                        Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default))
+                        Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
             End Using
         End Sub
@@ -1038,15 +1041,15 @@ End Class
                         Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(19, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(20, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(21, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(22, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(23, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(24, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(25, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(26, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(27, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(17, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
             End Using
         End Sub
@@ -1101,9 +1104,9 @@ End Class
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -1250,9 +1253,9 @@ End Class
                         Row(4, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -1500,9 +1503,9 @@ End Class
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -1614,9 +1617,9 @@ End Class
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -1731,9 +1734,9 @@ End Class
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -1844,9 +1847,9 @@ End Class
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -1987,9 +1990,9 @@ End Class
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(14, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -2134,9 +2137,9 @@ End Class
                         Row(4, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -2296,9 +2299,9 @@ End Class
                         Row(7, TableIndex.Field, EditAndContinueOperation.Default),
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -2461,9 +2464,9 @@ End Class
                         Row(7, TableIndex.Field, EditAndContinueOperation.Default),
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -2622,9 +2625,9 @@ End Class
                         Row(6, TableIndex.Field, EditAndContinueOperation.Default),
                         Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                         Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                        Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                        Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                        Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                        Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
                 End Using
 
                 diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
@@ -2930,12 +2933,12 @@ End Class
                     Row(3, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                    Row(19, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(20, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(21, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(22, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(23, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(24, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                    Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
 
             diff1.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
 {
@@ -3048,9 +3051,9 @@ End Class
                     Row(21, TableIndex.Field, EditAndContinueOperation.Default),
                     Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                    Row(25, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(26, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(27, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                    Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
 
             diff2.VerifyIL("C.VB$StateMachine_1_F.MoveNext()", "
 {
@@ -3167,12 +3170,12 @@ End Class
                     Row(4, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                    Row(28, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(29, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(30, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(31, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(32, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(33, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                    Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(17, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
 
         End Sub
 
@@ -3444,12 +3447,12 @@ End Class
                     Row(6, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                    Row(19, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(20, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(21, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(22, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(23, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(24, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                    Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
 
             diff1.VerifyIL("C.VB$StateMachine_4_F.MoveNext()", "
 {
@@ -3603,9 +3606,9 @@ End Class
                     Row(15, TableIndex.Field, EditAndContinueOperation.Default),
                     Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(9, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                    Row(25, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(26, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(27, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                    Row(6, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(13, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
 
             diff2.VerifyIL("C.VB$StateMachine_4_F.MoveNext()", "
 {
@@ -3765,12 +3768,12 @@ End Class
                     Row(7, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(12, TableIndex.MethodDef, EditAndContinueOperation.Default),
                     Row(15, TableIndex.MethodDef, EditAndContinueOperation.Default),
-                    Row(28, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(29, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(30, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(31, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(32, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
-                    Row(33, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
+                    Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(12, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(15, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                    Row(17, TableIndex.CustomAttribute, EditAndContinueOperation.Default))
         End Sub
 
         <Fact>
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/LambdaTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/LambdaTests.vb
index 070a4891db66b..98ce6ab7d33a6 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/LambdaTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/LambdaTests.vb
@@ -2164,5 +2164,223 @@ In getter
 ]]>)
         End Sub
 
+        <WorkItem(53593, "https://github.com/dotnet/roslyn/issues/53593")>
+        <Fact()>
+        Public Sub Issue53593_1()
+
+            Dim compilationDef =
+<compilation>
+    <file name="a.vb">
+Public Class C0
+
+    Public a, b As New C1((Function(n) n + 1)(1))
+
+    Shared Sub Main()
+        Dim x as New C0()
+        System.Console.Write(x.a.F1)
+        System.Console.Write(x.b.F1)
+    End Sub
+End Class
+
+Public Class C1
+
+    Public F1 as Integer
+
+    Sub New(a As Integer)
+        F1 = a
+    End Sub
+End Class
+    </file>
+</compilation>
+
+            Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(compilationDef, TestOptions.ReleaseExe)
+
+            Dim verifier = CompileAndVerify(compilation, expectedOutput:="22")
+        End Sub
+
+        <WorkItem(53593, "https://github.com/dotnet/roslyn/issues/53593")>
+        <Fact()>
+        Public Sub Issue53593_2()
+
+            Dim compilationDef =
+<compilation>
+    <file name="a.vb">
+Public Class C0
+
+    Shared Sub Main()
+        Dim a, b As New C1((Function(n) n + 1)(1))
+        System.Console.Write(a.F1)
+        System.Console.Write(b.F1)
+    End Sub
+End Class
+
+Public Class C1
+
+    Public F1 as Integer
+
+    Sub New(a As Integer)
+        F1 = a
+    End Sub
+End Class
+    </file>
+</compilation>
+
+            Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(compilationDef, TestOptions.ReleaseExe)
+
+            Dim verifier = CompileAndVerify(compilation, expectedOutput:="22")
+        End Sub
+
+        <WorkItem(53593, "https://github.com/dotnet/roslyn/issues/53593")>
+        <Fact()>
+        Public Sub Issue53593_3()
+
+            Dim compilationDef =
+<compilation>
+    <file name="a.vb">
+Public Class C0
+
+    Public a, b As New C1((Function(n) n + 1)(1))
+
+    Shared Sub Main()
+        Dim x as New C0()
+        System.Console.Write(x.a.F1)
+        System.Console.Write(x.b.F1)
+
+        x = New C0(True)
+        System.Console.Write(x.a.F1)
+        System.Console.Write(x.b.F1)
+    End Sub
+
+    Sub New()
+    End Sub
+
+    Sub New(b as Boolean)
+    End Sub
+End Class
+
+Public Class C1
+
+    Public F1 as Integer
+
+    Sub New(a As Integer)
+        F1 = a
+    End Sub
+End Class
+    </file>
+</compilation>
+
+            Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(compilationDef, TestOptions.ReleaseExe)
+
+            Dim verifier = CompileAndVerify(compilation, expectedOutput:="2222")
+        End Sub
+
+        <WorkItem(53593, "https://github.com/dotnet/roslyn/issues/53593")>
+        <Fact()>
+        Public Sub Issue53593_4()
+
+            Dim compilationDef =
+<compilation>
+    <file name="a.vb">
+Public Class C0
+
+    Public a, b As New C1((Function(n1) (Function(n2) n2 + 1)(n1))(1))
+
+    Shared Sub Main()
+        Dim x as New C0()
+        System.Console.Write(x.a.F1)
+        System.Console.Write(x.b.F1)
+    End Sub
+End Class
+
+Public Class C1
+
+    Public F1 as Integer
+
+    Sub New(a As Integer)
+        F1 = a
+    End Sub
+End Class
+    </file>
+</compilation>
+
+            Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(compilationDef, TestOptions.ReleaseExe)
+
+            Dim verifier = CompileAndVerify(compilation, expectedOutput:="22")
+        End Sub
+
+        <WorkItem(53593, "https://github.com/dotnet/roslyn/issues/53593")>
+        <Fact()>
+        Public Sub Issue53593_5()
+
+            Dim compilationDef =
+<compilation>
+    <file name="a.vb">
+Public Class C0
+
+    Shared Sub Main()
+        Test(Of Object)()
+    End Sub
+
+    Shared Sub Test(Of T)()
+        Dim a, b As New C1((Function(n)
+                                Dim x as T
+                                x = Nothing
+                                Return CObj(x) + n + 1
+                            End Function)(1))
+        System.Console.Write(a.F1)
+        System.Console.Write(b.F1)
+    End Sub
+End Class
+
+Public Class C1
+
+    Public F1 as Integer
+
+    Sub New(a As Integer)
+        F1 = a
+    End Sub
+End Class
+    </file>
+</compilation>
+
+            Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(compilationDef, TestOptions.ReleaseExe)
+
+            Dim verifier = CompileAndVerify(compilation, expectedOutput:="22")
+        End Sub
+
+        <WorkItem(53593, "https://github.com/dotnet/roslyn/issues/53593")>
+        <Fact()>
+        Public Sub Issue53593_6()
+
+            Dim compilationDef =
+<compilation>
+    <file name="a.vb">
+Public Class C0
+
+    Public WithEvents a, b As New C1((Function(n) n + 1)(1))
+
+    Shared Sub Main()
+        Dim x as New C0()
+        System.Console.Write(x.a.F1)
+        System.Console.Write(x.b.F1)
+    End Sub
+End Class
+
+Public Class C1
+
+    Public F1 as Integer
+
+    Sub New(a As Integer)
+        F1 = a
+    End Sub
+End Class
+    </file>
+</compilation>
+
+            Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(compilationDef, TestOptions.ReleaseExe)
+
+            Dim verifier = CompileAndVerify(compilation, expectedOutput:="22")
+        End Sub
+
     End Class
 End Namespace
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/UserDefinedBinaryOperators.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/UserDefinedBinaryOperators.vb
index 496041616321f..7b7ddd5713b60 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/UserDefinedBinaryOperators.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/UserDefinedBinaryOperators.vb
@@ -910,7 +910,7 @@ op_BitwiseOr
         End Sub
 
         <Fact>
-        Public Sub OperatorMapping_BothSignedAndUnsignedShift()
+        Public Sub OperatorMapping_BothSignedAndUnsignedShift_01()
 
             Dim ilSource =
             <![CDATA[
@@ -1026,6 +1026,143 @@ Option Strict On
 
 Imports System
 
+Module Module1
+    Sub Main()
+        Dim c As New C()
+        c = (New C << 1) >> 2 << 3
+    End Sub
+End Module
+    ]]></file>
+</compilation>
+
+            Dim compilation = CompilationUtils.CreateCompilationWithCustomILSource(compilationDef, ilSource.Value, includeVbRuntime:=True, options:=TestOptions.ReleaseExe)
+
+            Dim verifier = CompileAndVerify(compilation,
+                             expectedOutput:=
+            <![CDATA[
+op_LeftShift
+op_RightShift
+op_LeftShift
+]]>)
+        End Sub
+
+        <Fact>
+        Public Sub OperatorMapping_BothSignedAndUnsignedShift_02()
+
+            Dim ilSource =
+            <![CDATA[
+.class public auto ansi beforefieldinit C
+       extends [mscorlib]System.Object
+{
+  .method public hidebysig specialname rtspecialname 
+          instance void  .ctor() cil managed
+  {
+    // Code size       9 (0x9)
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
+    IL_0006:  br.s       IL_0008
+
+    IL_0008:  ret
+  } // end of method C::.ctor
+
+  .method public hidebysig specialname static 
+          class C  op_UnsignedLeftShift(class C x,
+                                int32 y) cil managed
+  {
+    // Code size       17 (0x11)
+    .maxstack  1
+    .locals init ([0] class C V_0)
+    IL_0000:  nop
+    IL_0001:  ldstr      "op_UnsignedLeftShift"
+    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_000b:  ldarg.0
+    IL_000c:  stloc.0
+    IL_000d:  br.s       IL_000f
+
+    IL_000f:  ldloc.0
+    IL_0010:  ret
+  } // end of method C::op_UnsignedLeftShift
+
+  .method public hidebysig specialname static 
+          class C  op_LeftShift(class C x,
+                                int32 y) cil managed
+  {
+    // Code size       17 (0x11)
+    .maxstack  1
+    .locals init ([0] class C V_0)
+    IL_0000:  nop
+    IL_0001:  ldstr      "op_LeftShift"
+    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_000b:  ldarg.0
+    IL_000c:  stloc.0
+    IL_000d:  br.s       IL_000f
+
+    IL_000f:  ldloc.0
+    IL_0010:  ret
+  } // end of method C::op_LeftShift
+
+  .method public hidebysig specialname static 
+          class C  op_RightShift(class C x,
+                                 int32 y) cil managed
+  {
+    // Code size       17 (0x11)
+    .maxstack  1
+    .locals init ([0] class C V_0)
+    IL_0000:  nop
+    IL_0001:  ldstr      "op_RightShift"
+    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_000b:  ldarg.0
+    IL_000c:  stloc.0
+    IL_000d:  br.s       IL_000f
+
+    IL_000f:  ldloc.0
+    IL_0010:  ret
+  } // end of method C::op_RightShift
+
+  .method public hidebysig specialname static 
+          class C  op_UnsignedRightShift(class C x,
+                                 int32 y) cil managed
+  {
+    // Code size       17 (0x11)
+    .maxstack  1
+    .locals init ([0] class C V_0)
+    IL_0000:  nop
+    IL_0001:  ldstr      "op_UnsignedRightShift"
+    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_000b:  ldarg.0
+    IL_000c:  stloc.0
+    IL_000d:  br.s       IL_000f
+
+    IL_000f:  ldloc.0
+    IL_0010:  ret
+  } // end of method C::op_UnsignedRightShift
+
+  .method public hidebysig static int32  Main() cil managed
+  {
+    .entrypoint
+    // Code size       7 (0x7)
+    .maxstack  1
+    .locals init ([0] int32 V_0)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  br.s       IL_0005
+
+    IL_0005:  ldloc.0
+    IL_0006:  ret
+  } // end of method C::Main
+
+} // end of class C
+]]>
+
+            Dim compilationDef =
+<compilation name="BothSignedAndUnsignedShift">
+    <file name="a.vb"><![CDATA[
+Option Strict On
+
+Imports System
+
 Module Module1
     Sub Main()
         Dim c As New C()
diff --git a/src/Compilers/VisualBasic/Test/Semantic/SourceGeneration/GeneratorDriverTests.vb b/src/Compilers/VisualBasic/Test/Semantic/SourceGeneration/GeneratorDriverTests.vb
index 17b3d68434888..6a4ed5e733d18 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/SourceGeneration/GeneratorDriverTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/SourceGeneration/GeneratorDriverTests.vb
@@ -254,6 +254,43 @@ End Namespace
 
         End Sub
 
+        <Fact>
+        Public Sub Does_Not_Enable_Incremental_Generators()
+
+            Dim parseOptions = TestOptions.Regular
+            Dim compilation As Compilation = GetCompilation(parseOptions)
+            Dim testGenerator As VBIncrementalGenerator = New VBIncrementalGenerator()
+            Dim driver As GeneratorDriver = VisualBasicGeneratorDriver.Create(ImmutableArray.Create(Of ISourceGenerator)(New IncrementalGeneratorWrapper(testGenerator)), parseOptions:=parseOptions)
+
+            Dim outputCompilation As Compilation = Nothing
+            Dim outputDiagnostics As ImmutableArray(Of Diagnostic) = Nothing
+            driver.RunGeneratorsAndUpdateCompilation(compilation, outputCompilation, outputDiagnostics)
+            outputDiagnostics.Verify()
+
+            Assert.Equal(1, outputCompilation.SyntaxTrees.Count())
+            Assert.Equal(compilation, compilation)
+            Assert.False(testGenerator._initialized)
+        End Sub
+
+        <Fact>
+        Public Sub Does_Not_Prefer_Incremental_Generators()
+
+            Dim parseOptions = TestOptions.Regular
+            Dim compilation As Compilation = GetCompilation(parseOptions)
+            Dim testGenerator As VBIncrementalAndSourceGenerator = New VBIncrementalAndSourceGenerator()
+            Dim driver As GeneratorDriver = VisualBasicGeneratorDriver.Create(ImmutableArray.Create(Of ISourceGenerator)(testGenerator), parseOptions:=parseOptions)
+
+            Dim outputCompilation As Compilation = Nothing
+            Dim outputDiagnostics As ImmutableArray(Of Diagnostic) = Nothing
+            driver.RunGeneratorsAndUpdateCompilation(compilation, outputCompilation, outputDiagnostics)
+            outputDiagnostics.Verify()
+
+            Assert.Equal(1, outputCompilation.SyntaxTrees.Count())
+            Assert.Equal(compilation, compilation)
+            Assert.False(testGenerator._initialized)
+            Assert.True(testGenerator._sourceInitialized)
+            Assert.True(testGenerator._sourceExecuted)
+        End Sub
 
         Shared Function GetCompilation(parseOptions As VisualBasicParseOptions, Optional source As String = "") As Compilation
             If (String.IsNullOrWhiteSpace(source)) Then
@@ -348,5 +385,39 @@ End Class
 
     End Class
 
+    <Generator(LanguageNames.VisualBasic)>
+    Friend Class VBIncrementalGenerator
+        Implements IIncrementalGenerator
+
+        Public _initialized As Boolean
+
+        Public Sub Initialize(context As IncrementalGeneratorInitializationContext) Implements IIncrementalGenerator.Initialize
+            _initialized = True
+        End Sub
+    End Class
+
+    <Generator(LanguageNames.VisualBasic)>
+    Friend Class VBIncrementalAndSourceGenerator
+        Implements IIncrementalGenerator
+        Implements ISourceGenerator
+
+        Public _initialized As Boolean
+        Public _sourceInitialized As Boolean
+        Public _sourceExecuted As Boolean
+
+        Public Sub Initialize(context As IncrementalGeneratorInitializationContext) Implements IIncrementalGenerator.Initialize
+            _initialized = True
+        End Sub
+
+        Public Sub Initialize(context As GeneratorInitializationContext) Implements ISourceGenerator.Initialize
+            _sourceInitialized = True
+        End Sub
+
+        Public Sub Execute(context As GeneratorExecutionContext) Implements ISourceGenerator.Execute
+            _sourceExecuted = True
+        End Sub
+
+
+    End Class
 
 End Namespace
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/LoadingMethods.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/LoadingMethods.vb
index 3003d9d737eb9..87e3287ef704a 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/LoadingMethods.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/LoadingMethods.vb
@@ -965,5 +965,124 @@ BC30390: 'C2.Private Overloads Sub M2()' is not accessible in this context becau
 ]]></expected>)
         End Sub
 
+        <Fact>
+        <WorkItem(53802, "https://github.com/dotnet/roslyn/issues/53802")>
+        Public Sub TestAmbiguousImplementationMethod()
+
+            Dim ilSource =
+            <![CDATA[
+.class interface public auto ansi abstract Interface`2<T, U>
+{
+    // Methods
+    .method public hidebysig abstract virtual  
+        void Method (
+            int32 i
+        ) cil managed 
+    {
+    } // end of method Interface`2::Method
+
+    .method public hidebysig abstract virtual  
+        void Method (
+            !T i
+        ) cil managed 
+    {
+    } // end of method Interface`2::Method
+
+    .method public hidebysig abstract virtual  
+        void Method (
+            !U i
+        ) cil managed 
+    {
+    } // end of method Interface`2::Method
+
+} // end of class Interface`2
+
+.class public auto ansi beforefieldinit Base`1<T>
+    extends [mscorlib]System.Object
+    implements class Interface`2<!T, !T>
+{
+    // Methods
+    .method public hidebysig newslot virtual 
+        void Method (
+            int32 i
+        ) cil managed 
+    {
+        .override method instance void class Interface`2<!T, !T>::Method(int32)
+        // Method begins at RVA 0x2050
+        // Code size 2 (0x2)
+        .maxstack 8
+
+        IL_0000: nop
+        IL_0001: ret
+    } // end of method Base`1::Method
+
+    .method public hidebysig newslot virtual 
+        void Method (
+            !T i
+        ) cil managed 
+    {
+        .override method instance void class Interface`2<!T, !T>::Method(!0)
+        .override method instance void class Interface`2<!T, !T>::Method(!1)
+        // Method begins at RVA 0x2050
+        // Code size 2 (0x2)
+        .maxstack 8
+
+        IL_0000: nop
+        IL_0001: ret
+    } // end of method Base`1::Method
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2053
+        // Code size 8 (0x8)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void [mscorlib]System.Object::.ctor()
+        IL_0006: nop
+        IL_0007: ret
+    } // end of method Base`1::.ctor
+
+} // end of class Base`1
+]]>
+
+            Dim compilationDef =
+<compilation name="SimpleTest1">
+    <file name="a.vb">
+Option Strict Off
+
+Imports System
+
+Module Module1
+    Sub Main()
+    End Sub
+End Module
+    </file>
+</compilation>
+
+            Dim compilation = CompilationUtils.CreateCompilationWithCustomILSource(compilationDef, ilSource.Value, includeVbRuntime:=True, options:=TestOptions.ReleaseExe)
+
+            Dim b = compilation.GlobalNamespace.GetTypeMember("Base")
+            Dim bI = b.Interfaces().Single()
+            Dim biMethods = bI.GetMembers()
+
+            Assert.Equal("Sub [Interface](Of T, U).Method(i As System.Int32)", biMethods(0).OriginalDefinition.ToTestDisplayString())
+            Assert.Equal("Sub [Interface](Of T, U).Method(i As T)", biMethods(1).OriginalDefinition.ToTestDisplayString())
+            Assert.Equal("Sub [Interface](Of T, U).Method(i As U)", biMethods(2).OriginalDefinition.ToTestDisplayString())
+
+            Dim bMethods = b.GetMembers()
+
+            Assert.Equal("Sub Base(Of T).Method(i As System.Int32)", bMethods(0).ToTestDisplayString())
+            Assert.Equal("Sub Base(Of T).Method(i As T)", bMethods(1).ToTestDisplayString())
+
+            Dim bM1Impl = DirectCast(bMethods(0), MethodSymbol).ExplicitInterfaceImplementations
+            Dim bM2Impl = DirectCast(bMethods(1), MethodSymbol).ExplicitInterfaceImplementations
+            Assert.Equal(biMethods(0), bM1Impl.Single())
+
+            Assert.Equal(2, bM2Impl.Length)
+            Assert.Equal(biMethods(1), bM2Impl(0))
+            Assert.Equal(biMethods(2), bM2Impl(1))
+        End Sub
     End Class
 End Namespace
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/RetargetingTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/RetargetingTests.vb
index b4380d1e3bf67..b61ce12c60488 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/RetargetingTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/RetargetingTests.vb
@@ -3255,6 +3255,40 @@ End Class
             Assert.True(DirectCast(cs, INamedTypeSymbol).IsSerializable)
         End Sub
 
+        <Fact>
+        Public Sub ExplicitInterfaceImplementationRetargetingGenericType()
+            Dim source1 = "
+Public Class C1(Of T)
+    Public Interface I1
+        Sub M(x As T)
+    End Interface
+End Class
+"
+            Dim ref1 = CreateEmptyCompilation("").ToMetadataReference()
+            Dim compilation1 = CreateCompilation(source1, references:={ref1})
+
+            Dim source2 = "
+Public Class C2(Of U) 
+    Implements C1(Of U).I1
+
+    Sub M(x As U) Implements C1(Of U).I1.M
+    End Sub
+End Class
+"
+            Dim compilation2 = CreateCompilation(source2, references:={compilation1.ToMetadataReference(), ref1, CreateEmptyCompilation("").ToMetadataReference()})
+
+            Dim compilation3 = CreateCompilation("", references:={compilation1.ToMetadataReference(), compilation2.ToMetadataReference()})
+
+            Assert.NotSame(compilation2.GetTypeByMetadataName("C1`1"), compilation3.GetTypeByMetadataName("C1`1"))
+
+            Dim c2 = compilation3.GetTypeByMetadataName("C2`1")
+            Assert.IsType(Of RetargetingNamedTypeSymbol)(c2)
+
+            Dim m = c2.GetMethod("M")
+
+            Assert.Equal(c2.Interfaces().Single().GetMethod("M"), m.ExplicitInterfaceImplementations.Single())
+        End Sub
+
     End Class
 #End If
 
diff --git a/src/EditorFeatures/CSharp/CSharpEditorResources.resx b/src/EditorFeatures/CSharp/CSharpEditorResources.resx
index 0498beacc31e0..3709e7f0ef1cb 100644
--- a/src/EditorFeatures/CSharp/CSharpEditorResources.resx
+++ b/src/EditorFeatures/CSharp/CSharpEditorResources.resx
@@ -437,4 +437,7 @@
   <data name="Outside_namespace" xml:space="preserve">
     <value>Outside namespace</value>
   </data>
+  <data name="Prefer_null_check_over_type_check" xml:space="preserve">
+    <value>Prefer 'null' check over type check</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/EditorFeatures/CSharp/CompleteStatement/CompleteStatementCommandHandler.cs b/src/EditorFeatures/CSharp/CompleteStatement/CompleteStatementCommandHandler.cs
index 5d42e7a200b3e..7cd49b0f0a6a5 100644
--- a/src/EditorFeatures/CSharp/CompleteStatement/CompleteStatementCommandHandler.cs
+++ b/src/EditorFeatures/CSharp/CompleteStatement/CompleteStatementCommandHandler.cs
@@ -223,6 +223,7 @@ private static bool MoveCaretToSemicolonPosition(
                 {
                     return MoveCaretToFinalPositionInStatement(speculative, currentNode, args, originalCaret, caret, true);
                 }
+
                 return false;
             }
             else if (syntaxFacts.IsStatement(currentNode)
diff --git a/src/EditorFeatures/CSharp/DecompiledSource/AssemblyResolver.cs b/src/EditorFeatures/CSharp/DecompiledSource/AssemblyResolver.cs
index 41df9fab1d1dc..fa8faed093731 100644
--- a/src/EditorFeatures/CSharp/DecompiledSource/AssemblyResolver.cs
+++ b/src/EditorFeatures/CSharp/DecompiledSource/AssemblyResolver.cs
@@ -71,6 +71,7 @@ public PEFile Resolve(IAssemblyReference name)
                 {
                     Log(CSharpEditorResources.WARN_Version_mismatch_Expected_0_Got_1, name.Version, assemblies[0].Identity.Version);
                 }
+
                 return MakePEFile(assemblies[0]);
             }
 
diff --git a/src/EditorFeatures/CSharp/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs b/src/EditorFeatures/CSharp/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
index bce834f0c12ec..8e4de95a1439a 100644
--- a/src/EditorFeatures/CSharp/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
+++ b/src/EditorFeatures/CSharp/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
@@ -101,6 +101,10 @@ private static IEnumerable<CodeStyleSetting> GetNullCheckingCodeStyleOptions(Ana
                 description: CSharpEditorResources.Prefer_conditional_delegate_call,
                 editorConfigOptions: editorConfigOptions,
                 visualStudioOptions: visualStudioOptions, updater: updaterService);
+            yield return CodeStyleSetting.Create(option: CSharpCodeStyleOptions.PreferNullCheckOverTypeCheck,
+                description: CSharpEditorResources.Prefer_null_check_over_type_check,
+                editorConfigOptions: editorConfigOptions,
+                visualStudioOptions: visualStudioOptions, updater: updaterService);
         }
 
         private static IEnumerable<CodeStyleSetting> GetModifierCodeStyleOptions(AnalyzerConfigOptions editorConfigOptions, OptionSet visualStudioOptions, OptionUpdater updaterService)
diff --git a/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/ReturnStatementHighlighter.cs b/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/ReturnStatementHighlighter.cs
index 8ab7f7733c7a3..223cada0e0768 100644
--- a/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/ReturnStatementHighlighter.cs
+++ b/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/ReturnStatementHighlighter.cs
@@ -63,6 +63,7 @@ private void HighlightRelatedKeywords(SyntaxNode node, List<TextSpan> spans)
                         if (!child.AsNode().IsReturnableConstruct())
                             HighlightRelatedKeywords(child.AsNode(), spans);
                     }
+
                     break;
             }
         }
diff --git a/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/YieldStatementHighlighter.cs b/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/YieldStatementHighlighter.cs
index 42f0e62caf917..dfffb011685b0 100644
--- a/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/YieldStatementHighlighter.cs
+++ b/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/YieldStatementHighlighter.cs
@@ -69,6 +69,7 @@ private void HighlightRelatedKeywords(SyntaxNode node, List<TextSpan> spans)
                             HighlightRelatedKeywords(child.AsNode(), spans);
                         }
                     }
+
                     break;
             }
         }
diff --git a/src/EditorFeatures/CSharp/InheritanceMargin/CSharpInheritanceMarginService.cs b/src/EditorFeatures/CSharp/InheritanceMargin/CSharpInheritanceMarginService.cs
index 02518184e9a8c..c1b8330890e7a 100644
--- a/src/EditorFeatures/CSharp/InheritanceMargin/CSharpInheritanceMarginService.cs
+++ b/src/EditorFeatures/CSharp/InheritanceMargin/CSharpInheritanceMarginService.cs
@@ -43,7 +43,9 @@ protected override ImmutableArray<SyntaxNode> GetMembers(IEnumerable<SyntaxNode>
                         SyntaxKind.MethodDeclaration,
                         SyntaxKind.PropertyDeclaration,
                         SyntaxKind.EventDeclaration,
-                        SyntaxKind.IndexerDeclaration))
+                        SyntaxKind.IndexerDeclaration,
+                        SyntaxKind.OperatorDeclaration,
+                        SyntaxKind.ConversionOperatorDeclaration))
                     {
                         builder.Add(member);
                     }
@@ -69,6 +71,8 @@ protected override SyntaxToken GetDeclarationToken(SyntaxNode declarationNode)
                 VariableDeclaratorSyntax variableDeclaratorNode => variableDeclaratorNode.Identifier,
                 TypeDeclarationSyntax baseTypeDeclarationNode => baseTypeDeclarationNode.Identifier,
                 IndexerDeclarationSyntax indexerDeclarationNode => indexerDeclarationNode.ThisKeyword,
+                OperatorDeclarationSyntax operatorDeclarationNode => operatorDeclarationNode.OperatorToken,
+                ConversionOperatorDeclarationSyntax conversionOperatorDeclarationNode => conversionOperatorDeclarationNode.Type.GetFirstToken(),
                 // Shouldn't reach here since the input declaration nodes are coming from GetMembers() method above
                 _ => throw ExceptionUtilities.UnexpectedValue(declarationNode),
             };
diff --git a/src/EditorFeatures/CSharp/Microsoft.CodeAnalysis.CSharp.EditorFeatures.csproj b/src/EditorFeatures/CSharp/Microsoft.CodeAnalysis.CSharp.EditorFeatures.csproj
index 37cc1a409ee8d..71eb76a34f9e7 100644
--- a/src/EditorFeatures/CSharp/Microsoft.CodeAnalysis.CSharp.EditorFeatures.csproj
+++ b/src/EditorFeatures/CSharp/Microsoft.CodeAnalysis.CSharp.EditorFeatures.csproj
@@ -6,7 +6,7 @@
     <RootNamespace>Microsoft.CodeAnalysis.Editor.CSharp</RootNamespace>
     <TargetFrameworks>netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ApplyNgenOptimization>partial</ApplyNgenOptimization>
+    <ApplyNgenOptimization Condition="'$(TargetFramework)' == 'netstandard2.0'">partial</ApplyNgenOptimization>
     <!-- NuGet -->
     <IsPackable>true</IsPackable>
     <PackageDescription>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf
index 08408a67dd409..9d05d7a21856f 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf
@@ -372,6 +372,11 @@
         <target state="translated">Preferovat lokální funkci před anonymní funkcí</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Upřednostňovat porovnávání vzorů</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf
index f602885cf3ed3..438c2f31e1494 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf
@@ -372,6 +372,11 @@
         <target state="translated">Lokale Funktion gegenüber anonymer Funktion bevorzugen</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Musterabgleich bevorzugen</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf
index cf02c7fb87f3d..5c28c9491507e 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf
@@ -372,6 +372,11 @@
         <target state="translated">Preferir una función local frente a una función anónima</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferir coincidencia de patrones</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf
index e407bf2c439e1..1973eec00c4e4 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf
@@ -372,6 +372,11 @@
         <target state="translated">Préférer une fonction locale à une fonction anonyme</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Préférer les critères spéciaux</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf
index 410040f6b23a0..2aa73552e0c36 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf
@@ -372,6 +372,11 @@
         <target state="translated">Preferisci la funzione locale a quella anonima</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferisci i criteri di ricerca</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf
index 2276f9274aa04..e64a9efb093c3 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf
@@ -372,6 +372,11 @@
         <target state="translated">匿名関数よりローカル関数を優先します</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">パターン マッチングを優先する</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf
index 44dd19bfe303e..f9cf0e5c4d7e2 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf
@@ -372,6 +372,11 @@
         <target state="translated">익명 함수보다 로컬 함수 선호</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">패턴 일치 선호</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf
index 3dc3b375fdf0d..486b71d2a215c 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf
@@ -372,6 +372,11 @@
         <target state="translated">Preferuj funkcję lokalną zamiast funkcji anonimowej</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferuj dopasowywanie do wzorca</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf
index 9003529dc846b..278d4c584974c 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf
@@ -372,6 +372,11 @@
         <target state="translated">Preferir usar função anônima em vez de local</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferir a correspondência de padrões</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf
index faa1c9676dd99..51902f502a6c2 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf
@@ -372,6 +372,11 @@
         <target state="translated">Предпочитать локальную функцию анонимной функции</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Предпочитать соответствие шаблону</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf
index c41985167cadc..6ff776740d16b 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf
@@ -372,6 +372,11 @@
         <target state="translated">Anonim işlevler yerine yerel işlevleri tercih et</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Desen eşleştirmeyi tercih et</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf
index cea90185fea94..57f7b1c1bca0b 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf
@@ -372,6 +372,11 @@
         <target state="translated">首选本地函数而不是匿名函数</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">首选模式匹配</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf
index 13988058c5938..4b7d00fbb0ef3 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf
@@ -372,6 +372,11 @@
         <target state="translated">使用區域函式優先於匿名函式</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">建議使用模式比對</target>
diff --git a/src/EditorFeatures/CSharpTest/AddParameter/AddParameterTests.cs b/src/EditorFeatures/CSharpTest/AddParameter/AddParameterTests.cs
index 3f5f22412b791..d3961df775dbc 100644
--- a/src/EditorFeatures/CSharpTest/AddParameter/AddParameterTests.cs
+++ b/src/EditorFeatures/CSharpTest/AddParameter/AddParameterTests.cs
@@ -2849,5 +2849,59 @@ void Test()
     }
 }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddParameter)]
+        [WorkItem(54408, "https://github.com/dotnet/roslyn/issues/54408")]
+        public async Task TestPositionalRecord()
+        {
+            await TestInRegularAndScriptAsync(@"
+var b = ""B"";
+var r = [|new R(1, b)|];
+
+record R(int A);
+
+namespace System.Runtime.CompilerServices
+{
+    public static class IsExternalInit { }
+}
+", @"
+var b = ""B"";
+var r = new R(1, b);
+
+record R(int A, string b);
+
+namespace System.Runtime.CompilerServices
+{
+    public static class IsExternalInit { }
+}
+", parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp9));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddParameter)]
+        [WorkItem(54408, "https://github.com/dotnet/roslyn/issues/54408")]
+        public async Task TestPositionalRecordStruct()
+        {
+            await TestInRegularAndScriptAsync(@"
+var b = ""B"";
+var r = [|new R(1, b)|];
+
+record struct R(int A);
+
+namespace System.Runtime.CompilerServices
+{
+    public static class IsExternalInit { }
+}
+", @"
+var b = ""B"";
+var r = new R(1, b);
+
+record struct R(int A, string b);
+
+namespace System.Runtime.CompilerServices
+{
+    public static class IsExternalInit { }
+}
+", parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp9));
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/CodeActions/AddAwait/AddAwaitTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/AddAwait/AddAwaitTests.cs
index 8a7547abf1828..977226441d9ac 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/AddAwait/AddAwaitTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/AddAwait/AddAwaitTests.cs
@@ -1448,5 +1448,21 @@ async Task<int> A()
         return await (null as Task<int>); }
 }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddAwait)]
+        [WorkItem(1345322, "https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1345322")]
+        public async Task TestOnTaskTypeItself()
+        {
+            await TestMissingAsync(
+@"using System.Threading.Tasks;
+
+class Program
+{
+    static async [||]Task Main(string[] args)
+    {
+    }
+}
+");
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/CodeActions/IntroduceParameter/IntroduceParameterTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/IntroduceParameter/IntroduceParameterTests.cs
index fea96d9c25894..df4d41e43624a 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/IntroduceParameter/IntroduceParameterTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/IntroduceParameter/IntroduceParameterTests.cs
@@ -1775,5 +1775,50 @@ void M1()
 }";
             await TestInRegularAndScriptAsync(code, expected, index: 0);
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceParameter)]
+        public async Task TestHighlightReturnType()
+        {
+            var code =
+@"using System;
+class TestClass
+{
+    [|int|] M(int x)
+    {
+        return x;
+    }
+
+    void M1()
+    {
+        M(5);
+    }
+}";
+            await TestMissingInRegularAndScriptAsync(code);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceParameter)]
+        public async Task TestTypeOfOnString()
+        {
+            var code =
+@"using System;
+class TestClass
+{
+    void M()
+    {
+        var x = [|typeof(string);|]
+    }
+}";
+
+            var expected =
+@"using System;
+class TestClass
+{
+    void M(Type x)
+    {
+    }
+}";
+
+            await TestInRegularAndScriptAsync(code, expected, index: 0);
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs b/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs
index 2795b666bef30..c3a43618a02c9 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/MoveType/MoveTypeTests.MoveToNewFile.cs
@@ -1408,5 +1408,51 @@ record CacheContext(String Message);
 
             await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText);
         }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.CodeActionsMoveType)]
+        public async Task MoveClassInTopLevelStatements()
+        {
+            var code = @"
+using ConsoleApp1;
+using System;
+
+var c = new C();
+Console.WriteLine(c.Hello);
+
+class [||]C
+{
+    public string Hello => ""Hello"";
+}";
+
+            var codeAfterMove = @"
+using ConsoleApp1;
+using System;
+
+var c = new C();
+Console.WriteLine(c.Hello);
+";
+
+            var expectedDocumentName = "C.cs";
+            var destinationDocumentText = @"class C
+{
+    public string Hello => ""Hello"";
+}";
+
+            await TestMoveTypeToNewFileAsync(code, codeAfterMove, expectedDocumentName, destinationDocumentText);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.CodeActionsMoveType)]
+        public async Task MissingInTopLevelStatementsOnly()
+        {
+            var code = @"
+using ConsoleApp1;
+using System;
+
+var c = new object();
+[||]Console.WriteLine(c.ToString());
+";
+
+            await TestMissingAsync(code);
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ConversionCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ConversionCompletionProviderTests.cs
index f25ebc09047f0..8caf3f8b9b40d 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ConversionCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ConversionCompletionProviderTests.cs
@@ -1651,6 +1651,43 @@ public static void Main()
         }
     }
 }
+");
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        [WorkItem(47511, "https://github.com/dotnet/roslyn/issues/47511")]
+        public async Task ExplicitUserDefinedConversionNullForgivingOperatorHandling()
+        {
+            await VerifyCustomCommitProviderAsync(@"
+#nullable enable
+
+public class C {
+    public static explicit operator int(C c) => 0;
+}
+
+public class Program
+{
+    public static void Main()
+    {
+        C? c = null;
+        var i = c!.$$
+    }
+}
+", "int", @"
+#nullable enable
+
+public class C {
+    public static explicit operator int(C c) => 0;
+}
+
+public class Program
+{
+    public static void Main()
+    {
+        C? c = null;
+        var i = ((int)c!)$$
+    }
+}
 ");
         }
     }
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/IndexerCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/IndexerCompletionProviderTests.cs
index 9af45df20124e..8fd6906bd669d 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/IndexerCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/IndexerCompletionProviderTests.cs
@@ -498,5 +498,44 @@ await VerifyItemInEditorBrowsableContextsAsync(
                 sourceLanguage: LanguageNames.CSharp,
                 referencedLanguage: LanguageNames.CSharp);
         }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        [WorkItem(47511, "https://github.com/dotnet/roslyn/issues/47511")]
+        public async Task IndexerNullForgivingOperatorHandling()
+        {
+            await VerifyCustomCommitProviderAsync(@"
+#nullable enable
+
+public class C
+{
+    public int this[int i] => i;
+}
+
+public class Program
+{
+    public static void Main()
+    {
+        C? c = null;
+        var i = c!.$$
+    }
+}
+", "this", @"
+#nullable enable
+
+public class C
+{
+    public int this[int i] => i;
+}
+
+public class Program
+{
+    public static void Main()
+    {
+        C? c = null;
+        var i = c![$$]
+    }
+}
+");
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OperatorCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OperatorCompletionProviderTests.cs
index 12165d91daa90..6776e7693a4f0 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OperatorCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OperatorCompletionProviderTests.cs
@@ -832,5 +832,44 @@ await VerifyItemInEditorBrowsableContextsAsync(
                 referencedLanguage: LanguageNames.CSharp,
                 hideAdvancedMembers: true);
         }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        [WorkItem(47511, "https://github.com/dotnet/roslyn/issues/47511")]
+        public async Task OperatorBinaryNullForgivingHandling()
+        {
+            await VerifyCustomCommitProviderAsync(@"
+#nullable enable
+
+public class C
+{
+    public static C operator +(C a, C b) => default;
+}
+
+public class Program
+{
+    public static void Main()
+    {
+        C? c = null;
+        var _ = c!.$$
+    }
+}
+", "+", @"
+#nullable enable
+
+public class C
+{
+    public static C operator +(C a, C b) => default;
+}
+
+public class Program
+{
+    public static void Main()
+    {
+        C? c = null;
+        var _ = c! + $$
+    }
+}
+");
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SnippetCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SnippetCompletionProviderTests.cs
index 339f971c62b2a..31cbca9838720 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SnippetCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SnippetCompletionProviderTests.cs
@@ -78,6 +78,10 @@ public async Task SnippetsNotInPreProcessorContextDirectiveNameAlreadyTyped()
         public async Task ShowRegionSnippetWithHashRTyped()
             => await VerifyItemExistsAsync(@"#r$$", MockSnippetInfoService.PreProcessorSnippetShortcut.Substring(1), sourceCodeKind: SourceCodeKind.Regular);
 
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task SnippetsInLineSpanDirective()
+            => await VerifyItemIsAbsentAsync(@"#line (1, 2) - (3, 4) $$", MockSnippetInfoService.PreProcessorSnippetShortcut, sourceCodeKind: SourceCodeKind.Regular);
+
         [WorkItem(968256, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/968256")]
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public async Task ShowSnippetsFromOtherContext()
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SymbolCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SymbolCompletionProviderTests.cs
index 01a35d5e86898..ae3decc2ed975 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SymbolCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SymbolCompletionProviderTests.cs
@@ -8070,6 +8070,40 @@ public void goo()
             await VerifyItemIsAbsentAsync(markup, "value");
         }
 
+        [WorkItem(54361, "https://github.com/dotnet/roslyn/issues/54361")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ConditionalAccessNullableIsUnwrappedOnParameter()
+        {
+            var markup = @"
+class A
+{
+    void M(System.DateTime? dt)
+    {
+        dt?.$$
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "Day");
+            await VerifyItemIsAbsentAsync(markup, "Value");
+        }
+
+        [WorkItem(54361, "https://github.com/dotnet/roslyn/issues/54361")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NullableIsNotUnwrappedOnParameter()
+        {
+            var markup = @"
+class A
+{
+    void M(System.DateTime? dt)
+    {
+        dt.$$
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "Value");
+            await VerifyItemIsAbsentAsync(markup, "Day");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public async Task CompletionAfterConditionalIndexing()
         {
@@ -9576,6 +9610,7 @@ void goo()
             {
                 await VerifyItemExistsAsync(markup, "Item" + i);
             }
+
             await VerifyItemExistsAsync(markup, "ToString");
 
             await VerifyItemIsAbsentAsync(markup, "Item1");
@@ -11293,5 +11328,38 @@ int M()
     }
 }", "y");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [WorkItem(53930, "https://github.com/dotnet/roslyn/issues/53930")]
+        public async Task TestTypeParameterConstraintedToInterfaceWithStatics()
+        {
+            var source = @"
+interface I1
+{
+    static void M0();
+    static abstract void M1();
+    abstract static int P1 { get; set; }
+    abstract static event System.Action E1;
+}
+
+interface I2
+{
+    static abstract void M2();
+}
+
+class Test
+{
+    void M<T>(T x) where T : I1, I2
+    {
+        T.$$
+    }
+}
+";
+            await VerifyItemIsAbsentAsync(source, "M0");
+            await VerifyItemExistsAsync(source, "M1");
+            await VerifyItemExistsAsync(source, "M2");
+            await VerifyItemExistsAsync(source, "P1");
+            await VerifyItemExistsAsync(source, "E1");
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/ConvertTupleToStruct/ConvertTupleToStructTests.cs b/src/EditorFeatures/CSharpTest/ConvertTupleToStruct/ConvertTupleToStructTests.cs
index 2116a5ac38b23..16f228209a291 100644
--- a/src/EditorFeatures/CSharpTest/ConvertTupleToStruct/ConvertTupleToStructTests.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertTupleToStruct/ConvertTupleToStructTests.cs
@@ -48,7 +48,9 @@ private static async Task TestAsync(
             if (index != 0)
                 Assert.NotNull(equivalenceKey);
 
-            var test = new VerifyCS.Test
+            options ??= new OptionsCollection(LanguageNames.CSharp);
+
+            await new VerifyCS.Test
             {
                 TestCode = text,
                 FixedCode = expected,
@@ -57,11 +59,8 @@ private static async Task TestAsync(
                 CodeActionIndex = index,
                 CodeActionEquivalenceKey = equivalenceKey,
                 ExactActionSetOffered = actions,
-            };
-
-            if (options != null)
-                test.Options.AddRange(options);
-            await test.RunAsync();
+                Options = { options },
+            }.RunAsync();
         }
 
         #region update containing member tests
@@ -2278,7 +2277,8 @@ public static implicit operator NewStruct((int a, int a) value)
         return new NewStruct(value.a, value.a);
     }
 }";
-            var test = new VerifyCS.Test
+
+            await new VerifyCS.Test
             {
                 TestCode = text,
                 FixedCode = expected,
@@ -2349,11 +2349,9 @@ public static implicit operator NewStruct((int a, int a) value)
     // /0/Test0.cs(49,45): error CS0229: Ambiguity between '(int a, int a).a' and '(int a, int a).a'
     DiagnosticResult.CompilerError("CS0229").WithSpan(49, 45, 49, 46).WithArguments("(int a, int a).a", "(int a, int a).a"),
                     }
-                }
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                },
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Theory, CombinatorialData, Trait(Traits.Feature, Traits.Features.CodeActionsConvertTupleToStruct)]
@@ -3352,7 +3350,7 @@ void Goo()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestState =
                 {
@@ -3373,10 +3371,8 @@ void Goo()
                 CodeActionIndex = 1,
                 CodeActionEquivalenceKey = Scope.ContainingType.ToString(),
                 TestHost = host,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         #endregion update containing project tests
@@ -3511,7 +3507,7 @@ void Goo()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 CodeActionIndex = 2,
                 CodeActionEquivalenceKey = Scope.ContainingProject.ToString(),
@@ -3524,10 +3520,8 @@ void Goo()
                 {
                     Sources = { expected1, expected2 },
                 },
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         #endregion
@@ -3638,7 +3632,7 @@ void Goo()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 CodeActionIndex = 3,
                 CodeActionEquivalenceKey = Scope.DependentProjects.ToString(),
@@ -3667,10 +3661,8 @@ void Goo()
                         }
                     },
                 },
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Theory, CombinatorialData, Trait(Traits.Feature, Traits.Features.CodeActionsConvertTupleToStruct)]
@@ -3777,7 +3769,7 @@ void Goo()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 CodeActionIndex = 3,
                 CodeActionEquivalenceKey = Scope.DependentProjects.ToString(),
@@ -3798,10 +3790,8 @@ void Goo()
                         ["DependencyProject"] = { Sources = { expected2 } }
                     },
                 },
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         #endregion
diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/AddExplicitCast/AddExplicitCastTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/AddExplicitCast/AddExplicitCastTests.cs
index 76b210500ddf9..c959df4927171 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/AddExplicitCast/AddExplicitCastTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/AddExplicitCast/AddExplicitCastTests.cs
@@ -2522,6 +2522,7 @@ public Test(string s, Base b, int i, params object[] list) : this(d : [||]b, s :
                 var (actions, actionToInvoke) = await GetCodeActionsAsync(workspace, new TestParameters());
                 Assert.Equal(2, actions.Length);
             }
+
             var expect_0 =
 @"
 class Program
@@ -2671,6 +2672,7 @@ void M()
                 var (actions, actionToInvoke) = await GetCodeActionsAsync(workspace, new TestParameters());
                 Assert.Equal(2, actions.Length);
             }
+
             var expect_0 =
 @"
 class Program
@@ -2746,6 +2748,7 @@ void M()
                 var (actions, actionToInvoke) = await GetCodeActionsAsync(workspace, new TestParameters());
                 Assert.Equal(3, actions.Length);
             }
+
             var expect_0 =
 @"
 class Program
diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs
index de59148fc6de0..0fc6908c7a5b2 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs
@@ -927,6 +927,7 @@ public void AnalyzeNode(SyntaxNodeAnalysisContext context)
                                 {
                                     context.ReportDiagnostic(Diagnostic.Create(Descriptor, trivia.GetLocation()));
                                 }
+
                                 break;
                         }
                     }
diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/UpgradeProject/UpgradeProjectTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/UpgradeProject/UpgradeProjectTests.cs
index 53caa05b1a1f1..ef4139fe6426c 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/UpgradeProject/UpgradeProjectTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/UpgradeProject/UpgradeProjectTests.cs
@@ -1001,7 +1001,7 @@ interface I2<out T1>
     static T1 M1([|T1|] x) => x;
 }
 ",
-                expected: LanguageVersion.Preview,
+                expected: LanguageVersion.CSharp9,
                 new CSharpParseOptions(LanguageVersion.CSharp8));
         }
 
@@ -1011,13 +1011,13 @@ public async Task UpgradeProjectForSealedToStringInRecords_CS8912()
             await TestLanguageVersionUpgradedAsync(
 @"
 <Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"" LanguageVersion=""9"">
         <ProjectReference>Assembly2</ProjectReference>
         <Document FilePath=""Derived.cs"">
 record [|Derived|] : Base;
         </Document>
     </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"" LanguageVersion=""Preview"">
+    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"" LanguageVersion=""10"">
         <Document FilePath=""Base.cs"">
 public record Base
 {
@@ -1027,7 +1027,48 @@ public record Base
     </Project>
 </Workspace>
 ",
-                expected: LanguageVersion.Preview,
+                expected: LanguageVersion.CSharp10,
+                new CSharpParseOptions(LanguageVersion.CSharp9));
+        }
+
+        [Fact]
+        public async Task UpgradeProjectForTargetTypedNew()
+        {
+            await TestLanguageVersionUpgradedAsync(@"
+class Test
+{
+    Test t = [|new()|];
+}",
+                LanguageVersion.CSharp9,
+                new CSharpParseOptions(LanguageVersion.CSharp8));
+        }
+
+        [Fact]
+        public async Task UpgradeProjectForGlobalUsing()
+        {
+            await TestLanguageVersionUpgradedAsync(@"
+[|global using System;|]
+",
+                LanguageVersion.CSharp10,
+                new CSharpParseOptions(LanguageVersion.CSharp9));
+        }
+
+        [Fact]
+        public async Task UpgradeProjectForImplicitImplementationOfNonPublicMemebers_CS8704()
+        {
+            await TestLanguageVersionUpgradedAsync(
+@"
+public interface I1
+{
+    protected void M01();
+}
+
+class C1 : [|I1|]
+{
+    public void M01() {}
+}
+",
+                expected: LanguageVersion.CSharp10,
                 new CSharpParseOptions(LanguageVersion.CSharp9));
         }
     }
diff --git a/src/EditorFeatures/CSharpTest/DocumentationComments/DocumentationCommentTests.cs b/src/EditorFeatures/CSharpTest/DocumentationComments/DocumentationCommentTests.cs
index 326a0fc2cdb94..80b636ce7a8ed 100644
--- a/src/EditorFeatures/CSharpTest/DocumentationComments/DocumentationCommentTests.cs
+++ b/src/EditorFeatures/CSharpTest/DocumentationComments/DocumentationCommentTests.cs
@@ -54,6 +54,22 @@ record R;";
             VerifyTypingCharacter(code, expected);
         }
 
+        [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
+        public void TypingCharacter_RecordStruct()
+        {
+            var code =
+@"//$$
+record struct R;";
+
+            var expected =
+@"/// <summary>
+/// $$
+/// </summary>
+record struct R;";
+
+            VerifyTypingCharacter(code, expected);
+        }
+
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
         public void TypingCharacter_RecordWithPositionalParameters()
         {
@@ -72,6 +88,24 @@ record R(string S, int I);";
             VerifyTypingCharacter(code, expected);
         }
 
+        [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
+        public void TypingCharacter_RecordStructWithPositionalParameters()
+        {
+            var code =
+@"//$$
+record struct R(string S, int I);";
+
+            var expected =
+@"/// <summary>
+/// $$
+/// </summary>
+/// <param name=""S""></param>
+/// <param name=""I""></param>
+record struct R(string S, int I);";
+
+            VerifyTypingCharacter(code, expected);
+        }
+
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
         public void TypingCharacter_Class_NewLine()
         {
@@ -1515,6 +1549,20 @@ record R;";
             VerifyInsertCommentCommand(code, expected);
         }
 
+        [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
+        public void Command_RecordStruct()
+        {
+            var code = "record struct R$$;";
+
+            var expected =
+@"/// <summary>
+/// $$
+/// </summary>
+record struct R;";
+
+            VerifyInsertCommentCommand(code, expected);
+        }
+
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
         public void Command_RecordWithPositionalParameters()
         {
@@ -1531,6 +1579,22 @@ record R(string S, int I);";
             VerifyInsertCommentCommand(code, expected);
         }
 
+        [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
+        public void Command_RecordStructWithPositionalParameters()
+        {
+            var code = "record struct R$$(string S, int I);";
+
+            var expected =
+@"/// <summary>
+/// $$
+/// </summary>
+/// <param name=""S""></param>
+/// <param name=""I""></param>
+record struct R(string S, int I);";
+
+            VerifyInsertCommentCommand(code, expected);
+        }
+
         [WorkItem(4817, "https://github.com/dotnet/roslyn/issues/4817")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
         public void Command_Class_AutoGenerateXmlDocCommentsOff()
diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/ActiveStatementTests.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/ActiveStatementTests.cs
index 4fa5b89fd2ade..a5306fe2a6398 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/ActiveStatementTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/ActiveStatementTests.cs
@@ -1867,7 +1867,7 @@ public C() {}
             var active = GetActiveStatements(src1, src2);
 
             edits.VerifyRudeDiagnostics(active,
-                Diagnostic(RudeEditKind.ModifiersUpdate, "const int a = 1", FeaturesResources.const_field));
+                Diagnostic(RudeEditKind.ModifiersUpdate, "a = 1", FeaturesResources.const_field));
         }
 
         [Fact]
@@ -1917,7 +1917,7 @@ public C() {}
             var active = GetActiveStatements(src1, src2);
 
             edits.VerifyRudeDiagnostics(active,
-                Diagnostic(RudeEditKind.ModifiersUpdate, "const int a = 1, b = 2", FeaturesResources.const_field));
+                Diagnostic(RudeEditKind.ModifiersUpdate, "a = 1", FeaturesResources.const_field));
         }
 
         [Fact]
diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestHelpers.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestHelpers.cs
index 4b417edbe5a0a..9e69b9b3ad552 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestHelpers.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/CSharpEditAndContinueTestHelpers.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests
diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs
index fd1d4962d4c04..794c9d3f61a9e 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs
@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
+using Roslyn.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests
@@ -34,6 +35,17 @@ internal enum MethodKind
             ConstructorWithParameters
         }
 
+        public static string GetResource(string keyword)
+            => keyword switch
+            {
+                "class" => FeaturesResources.class_,
+                "struct" => CSharpFeaturesResources.struct_,
+                "interface" => FeaturesResources.interface_,
+                "record" => CSharpFeaturesResources.record_,
+                "record struct" => CSharpFeaturesResources.record_struct,
+                _ => throw ExceptionUtilities.UnexpectedValue(keyword)
+            };
+
         internal static SemanticEditDescription[] NoSemanticEdits = Array.Empty<SemanticEditDescription>();
 
         internal static RudeEditDiagnosticDescription Diagnostic(RudeEditKind rudeEditKind, string squiggle, params string[] arguments)
diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/TopLevelEditingTests.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/TopLevelEditingTests.cs
index 095a59d3feecc..3827ac1e2d9b2 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/TopLevelEditingTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/TopLevelEditingTests.cs
@@ -428,7 +428,7 @@ public void ExternAliasDelete()
 
         #endregion
 
-        #region Attributes
+        #region Assembly/Module Attributes
 
         [Fact]
         public void Insert_TopLevelAttribute()
@@ -492,243 +492,157 @@ public void Reorder_TopLevelAttribute()
             edits.VerifyRudeDiagnostics();
         }
 
-        [Fact]
-        public void UpdateAttributes1()
-        {
-            var attribute = "public class A1Attribute : System.Attribute { }\n\n" +
-                            "public class A2Attribute : System.Attribute { }\n\n";
-
-            var src1 = attribute + "[A1]class C { }";
-            var src2 = attribute + "[A2]class C { }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [[A1]class C { }]@98 -> [[A2]class C { }]@98");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
-        }
-
-        [Fact]
-        public void UpdateAttributes2()
-        {
-            var src1 = "[System.Obsolete(\"1\")]class C { }";
-            var src2 = "[System.Obsolete(\"2\")]class C { }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [[System.Obsolete(\"1\")]class C { }]@0 -> [[System.Obsolete(\"2\")]class C { }]@0");
+        #endregion
 
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
-        }
+        #region Types
 
-        [Fact]
-        public void DeleteAttributes()
+        [Theory]
+        [InlineData("class", "struct")]
+        [InlineData("class", "record")] // TODO: Allow this conversion: https://github.com/dotnet/roslyn/issues/51874
+        [InlineData("class", "record struct")]
+        [InlineData("struct", "record struct")] // TODO: Allow this conversion: https://github.com/dotnet/roslyn/issues/51874
+        public void Type_Kind_Update(string oldKeyword, string newKeyword)
         {
-            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
-                            "public class BAttribute : System.Attribute { }\n\n";
-
-            var src1 = attribute + "[A, B]class C { }";
-            var src2 = attribute + "[A]class C { }";
+            var src1 = oldKeyword + " C { }";
+            var src2 = newKeyword + " C { }";
 
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifyEdits(
-                "Update [[A, B]class C { }]@96 -> [[A]class C { }]@96");
+                "Update [" + oldKeyword + " C { }]@0 -> [" + newKeyword + " C { }]@0");
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
+                Diagnostic(RudeEditKind.TypeKindUpdate, newKeyword + " C"));
         }
 
         [Fact]
-        public void DeleteAttributes2()
+        public void Type_Modifiers_Static_Remove()
         {
-            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
-                            "public class BAttribute : System.Attribute { }\n\n";
-
-            var src1 = attribute + "[B, A]class C { }";
-            var src2 = attribute + "[A]class C { }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [[B, A]class C { }]@96 -> [[A]class C { }]@96");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
-        }
-
-        [Fact]
-        public void InsertAttributes_SupportedByRuntime()
-        {
-            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
-                            "public class BAttribute : System.Attribute { }\n\n";
-
-            var src1 = attribute + "[A]class C { }";
-            var src2 = attribute + "[A, B]class C { }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [[A]class C { }]@96 -> [[A, B]class C { }]@96");
-
-            edits.VerifySemantics(
-                ActiveStatementsDescription.Empty,
-                new[] { SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C")) },
-                capabilities: EditAndContinueTestHelpers.Net5RuntimeCapabilities | EditAndContinueCapabilities.ChangeCustomAttributes);
-        }
-
-        [Fact]
-        public void InsertAttributes1()
-        {
-            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
-                            "public class BAttribute : System.Attribute { }\n\n";
-
-            var src1 = attribute + "[A]class C { }";
-            var src2 = attribute + "[A, B]class C { }";
+            var src1 = "public static class C { }";
+            var src2 = "public class C { }";
 
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifyEdits(
-                "Update [[A]class C { }]@96 -> [[A, B]class C { }]@96");
+                "Update [public static class C { }]@0 -> [public class C { }]@0");
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
+                Diagnostic(RudeEditKind.ModifiersUpdate, "public class C", FeaturesResources.class_));
         }
 
-        [Fact]
-        public void InsertAttributes2()
+        [Theory]
+        [InlineData("public")]
+        [InlineData("protected")]
+        [InlineData("private")]
+        [InlineData("private protected")]
+        [InlineData("internal protected")]
+        public void Type_Modifiers_Accessibility_Change(string accessibility)
         {
-            var attribute = "public class AAttribute : System.Attribute { }\n\n";
-
-            var src1 = attribute + "class C { }";
-            var src2 = attribute + "[A]class C { }";
+            var src1 = accessibility + " class C { }";
+            var src2 = "class C { }";
 
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifyEdits(
-                "Update [class C { }]@48 -> [[A]class C { }]@48");
+                "Update [" + accessibility + " class C { }]@0 -> [class C { }]@0");
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
-        }
-
-        [Fact]
-        public void ReorderAttributes1()
-        {
-            var src1 = "[A(1), B(2), C(3)]class C { }";
-            var src2 = "[C(3), A(1), B(2)]class C { }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [[A(1), B(2), C(3)]class C { }]@0 -> [[C(3), A(1), B(2)]class C { }]@0");
-
-            edits.VerifyRudeDiagnostics();
+                Diagnostic(RudeEditKind.ChangingAccessibility, "class C", FeaturesResources.class_));
         }
 
-        [Fact]
-        public void ReorderAttributes2()
-        {
-            var src1 = "[A, B, C]class C { }";
-            var src2 = "[B, C, A]class C { }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [[A, B, C]class C { }]@0 -> [[B, C, A]class C { }]@0");
+        [Theory]
+        [InlineData("public", "public")]
+        [InlineData("internal", "internal")]
+        [InlineData("", "internal")]
+        [InlineData("internal", "")]
+        [InlineData("protected", "protected")]
+        [InlineData("private", "private")]
+        [InlineData("private protected", "private protected")]
+        [InlineData("internal protected", "internal protected")]
+        public void Type_Modifiers_Accessibility_Partial(string accessibilityA, string accessibilityB)
+        {
+            var srcA1 = accessibilityA + " partial class C { }";
+            var srcB1 = "partial class C { }";
+            var srcA2 = "partial class C { }";
+            var srcB2 = accessibilityB + " partial class C { }";
 
-            edits.VerifyRudeDiagnostics();
+            EditAndContinueValidation.VerifySemantics(
+                new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
+                new[]
+                {
+                    DocumentResults(),
+                    DocumentResults(),
+                });
         }
 
         [Fact]
-        public void ReorderAndUpdateAttributes()
+        public void Type_Modifiers_Internal_Remove()
         {
-            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
-                            "public class BAttribute : System.Attribute { }\n\n";
-
-            var src1 = attribute + "[System.Obsolete(\"1\"), A, B]class C { }";
-            var src2 = attribute + "[A, B, System.Obsolete(\"2\")]class C { }";
+            var src1 = "internal interface C { }";
+            var src2 = "interface C { }";
 
             var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [[System.Obsolete(\"1\"), A, B]class C { }]@96 -> [[A, B, System.Obsolete(\"2\")]class C { }]@96");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
+            edits.VerifySemantics();
         }
 
-        #endregion
-
-        #region Classes, Structs, Interfaces
-
         [Fact]
-        public void TypeKindUpdate()
+        public void Type_Modifiers_Internal_Add()
         {
-            var src1 = "class C { }";
-            var src2 = "struct C { }";
+            var src1 = "struct C { }";
+            var src2 = "internal struct C { }";
 
             var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [class C { }]@0 -> [struct C { }]@0");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.TypeKindUpdate, "struct C", CSharpFeaturesResources.struct_));
+            edits.VerifySemantics();
         }
 
-        [Fact]
-        public void TypeKindUpdate2()
+        [Theory]
+        [InlineData("class")]
+        [InlineData("struct")]
+        [InlineData("interface")]
+        [InlineData("record")]
+        [InlineData("record struct")]
+        public void Type_Modifiers_NestedPrivateInInterface_Remove(string keyword)
         {
-            // TODO: Allow this conversion: https://github.com/dotnet/roslyn/issues/51874
-            var src1 = "class C { }";
-            var src2 = "record C { }";
+            var src1 = "interface C { private " + keyword + " S { } }";
+            var src2 = "interface C { " + keyword + " S { } }";
 
             var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [class C { }]@0 -> [record C { }]@0");
-
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.TypeKindUpdate, "record C", CSharpFeaturesResources.record_));
+                Diagnostic(RudeEditKind.ChangingAccessibility, keyword + " S", GetResource(keyword)));
         }
 
-        [Fact]
-        public void TypeKindUpdate3()
+        [Theory]
+        [InlineData("class")]
+        [InlineData("struct")]
+        [InlineData("interface")]
+        [InlineData("record")]
+        [InlineData("record struct")]
+        public void Type_Modifiers_NestedPrivateInClass_Add(string keyword)
         {
-            var src1 = "record C { }";
-            var src2 = "record struct C { }";
+            var src1 = "class C { " + keyword + " S { } }";
+            var src2 = "class C { private " + keyword + " S { } }";
 
             var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [record C { }]@0 -> [record struct C { }]@0");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.TypeKindUpdate, "record struct C", CSharpFeaturesResources.record_struct));
+            edits.VerifySemantics();
         }
 
-        [Fact]
-        public void Class_Modifiers_Update()
+        [Theory]
+        [InlineData("class")]
+        [InlineData("struct")]
+        [InlineData("interface")]
+        [InlineData("record")]
+        [InlineData("record struct")]
+        public void Type_Modifiers_NestedPublicInInterface_Add(string keyword)
         {
-            var src1 = "public static class C { }";
-            var src2 = "public class C { }";
+            var src1 = "interface C { " + keyword + " S { } }";
+            var src2 = "interface C { public " + keyword + " S { } }";
 
             var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [public static class C { }]@0 -> [public class C { }]@0");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "public class C", FeaturesResources.class_));
+            edits.VerifySemantics();
         }
 
         [Fact, WorkItem(48628, "https://github.com/dotnet/roslyn/issues/48628")]
-        public void Class_ModifiersUpdate_IgnoreUnsafe()
+        public void Type_Modifiers_Unsafe_Add()
         {
             var src1 = "public class C { }";
             var src2 = "public unsafe class C { }";
@@ -742,7 +656,7 @@ public void Class_ModifiersUpdate_IgnoreUnsafe()
         }
 
         [Fact, WorkItem(48628, "https://github.com/dotnet/roslyn/issues/48628")]
-        public void ModifiersUpdate_IgnoreUnsafe()
+        public void Type_Modifiers_Unsafe_Remove()
         {
             var src1 = @"
 using System;
@@ -789,7 +703,7 @@ public event Action<int> A { add { } remove { } }
         }
 
         [Fact, WorkItem(48628, "https://github.com/dotnet/roslyn/issues/48628")]
-        public void ModifiersUpdate_IgnoreUnsafe2()
+        public void Type_Modifiers_Unsafe_DeleteInsert()
         {
             var srcA1 = "partial class C { unsafe void F() { } }";
             var srcB1 = "partial class C { }";
@@ -809,7 +723,7 @@ public void ModifiersUpdate_IgnoreUnsafe2()
         }
 
         [Fact]
-        public void Struct_Modifiers_Ref_Update1()
+        public void Type_Modifiers_Ref_Add()
         {
             var src1 = "public struct C { }";
             var src2 = "public ref struct C { }";
@@ -824,7 +738,7 @@ public void Struct_Modifiers_Ref_Update1()
         }
 
         [Fact]
-        public void Struct_Modifiers_Ref_Update2()
+        public void Type_Modifiers_Ref_Remove()
         {
             var src1 = "public ref struct C { }";
             var src2 = "public struct C { }";
@@ -839,7 +753,7 @@ public void Struct_Modifiers_Ref_Update2()
         }
 
         [Fact]
-        public void Struct_Modifiers_Readonly_Update1()
+        public void Type_Modifiers_ReadOnly_Add()
         {
             var src1 = "public struct C { }";
             var src2 = "public readonly struct C { }";
@@ -854,7 +768,7 @@ public void Struct_Modifiers_Readonly_Update1()
         }
 
         [Fact]
-        public void Struct_Modifiers_Readonly_Update2()
+        public void Type_Modifiers_ReadOnly_Remove()
         {
             var src1 = "public readonly struct C { }";
             var src2 = "public struct C { }";
@@ -869,49 +783,175 @@ public void Struct_Modifiers_Readonly_Update2()
         }
 
         [Fact]
-        public void Interface_Modifiers_Update()
+        public void Type_Attribute_Update_NotSupportedByRuntime1()
         {
-            var src1 = "public interface C { }";
-            var src2 = "interface C { }";
+            var attribute = "public class A1Attribute : System.Attribute { }\n\n" +
+                            "public class A2Attribute : System.Attribute { }\n\n";
+
+            var src1 = attribute + "[A1]class C { }";
+            var src2 = attribute + "[A2]class C { }";
 
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifyEdits(
-                "Update [public interface C { }]@0 -> [interface C { }]@0");
+                "Update [[A1]class C { }]@98 -> [[A2]class C { }]@98");
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "interface C", FeaturesResources.interface_));
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
         }
 
         [Fact]
-        public void Struct_Modifiers_Update()
+        public void Type_Attribute_Update_NotSupportedByRuntime2()
         {
-            var src1 = "struct C { }";
-            var src2 = "public struct C { }";
+            var src1 = "[System.Obsolete(\"1\")]class C { }";
+            var src2 = "[System.Obsolete(\"2\")]class C { }";
 
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifyEdits(
-                "Update [struct C { }]@0 -> [public struct C { }]@0");
+                "Update [[System.Obsolete(\"1\")]class C { }]@0 -> [[System.Obsolete(\"2\")]class C { }]@0");
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "public struct C", CSharpFeaturesResources.struct_));
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
         }
 
         [Fact]
-        public void Struct_UnsafeModifier_Update()
+        public void Type_Attribute_Delete_NotSupportedByRuntime1()
         {
-            var src1 = "unsafe struct C { }";
-            var src2 = "struct C { }";
+            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
+                            "public class BAttribute : System.Attribute { }\n\n";
+
+            var src1 = attribute + "[A, B]class C { }";
+            var src2 = attribute + "[A]class C { }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [[A, B]class C { }]@96 -> [[A]class C { }]@96");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
+        }
+
+        [Fact]
+        public void Type_Attribute_Delete_NotSupportedByRuntime2()
+        {
+            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
+                            "public class BAttribute : System.Attribute { }\n\n";
+
+            var src1 = attribute + "[B, A]class C { }";
+            var src2 = attribute + "[A]class C { }";
 
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifyEdits(
-                "Update [unsafe struct C { }]@0 -> [struct C { }]@0");
+                "Update [[B, A]class C { }]@96 -> [[A]class C { }]@96");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
+        }
+
+        [Fact]
+        public void Type_Attribute_Add()
+        {
+            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
+                            "public class BAttribute : System.Attribute { }\n\n";
+
+            var src1 = attribute + "[A]class C { }";
+            var src2 = attribute + "[A, B]class C { }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [[A]class C { }]@96 -> [[A, B]class C { }]@96");
+
+            edits.VerifySemantics(
+                ActiveStatementsDescription.Empty,
+                new[] { SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C")) },
+                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities);
+        }
+
+        [Fact]
+        public void Type_Attribute_Add_NotSupportedByRuntime1()
+        {
+            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
+                            "public class BAttribute : System.Attribute { }\n\n";
+
+            var src1 = attribute + "[A]class C { }";
+            var src2 = attribute + "[A, B]class C { }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [[A]class C { }]@96 -> [[A, B]class C { }]@96");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
+        }
+
+        [Fact]
+        public void Type_Attribute_Add_NotSupportedByRuntime2()
+        {
+            var attribute = "public class AAttribute : System.Attribute { }\n\n";
+
+            var src1 = attribute + "class C { }";
+            var src2 = attribute + "[A]class C { }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [class C { }]@48 -> [[A]class C { }]@48");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
+        }
+
+        [Fact]
+        public void Type_Attribute_Reorder1()
+        {
+            var src1 = "[A(1), B(2), C(3)]class C { }";
+            var src2 = "[C(3), A(1), B(2)]class C { }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [[A(1), B(2), C(3)]class C { }]@0 -> [[C(3), A(1), B(2)]class C { }]@0");
 
             edits.VerifyRudeDiagnostics();
         }
 
+        [Fact]
+        public void Type_Attribute_Reorder2()
+        {
+            var src1 = "[A, B, C]class C { }";
+            var src2 = "[B, C, A]class C { }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [[A, B, C]class C { }]@0 -> [[B, C, A]class C { }]@0");
+
+            edits.VerifyRudeDiagnostics();
+        }
+
+        [Fact]
+        public void Type_Attribute_ReorderAndUpdate_NotSupportedByRuntime()
+        {
+            var attribute = "public class AAttribute : System.Attribute { }\n\n" +
+                            "public class BAttribute : System.Attribute { }\n\n";
+
+            var src1 = attribute + "[System.Obsolete(\"1\"), A, B]class C { }";
+            var src2 = attribute + "[A, B, System.Obsolete(\"2\")]class C { }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [[System.Obsolete(\"1\"), A, B]class C { }]@96 -> [[A, B, System.Obsolete(\"2\")]class C { }]@96");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "class C", FeaturesResources.class_));
+        }
+
         [Fact]
         public void Class_Name_Update1()
         {
@@ -1220,7 +1260,7 @@ public void RefStructInsert()
         }
 
         [Fact]
-        public void ReadOnlyStructInsert()
+        public void Struct_ReadOnly_Insert()
         {
             var src1 = "";
             var src2 = "readonly struct X { }";
@@ -1234,7 +1274,7 @@ public void ReadOnlyStructInsert()
         }
 
         [Fact]
-        public void RefStructUpdate()
+        public void Struct_RefModifier_Add()
         {
             var src1 = "struct X { }";
             var src2 = "ref struct X { }";
@@ -1249,7 +1289,7 @@ public void RefStructUpdate()
         }
 
         [Fact]
-        public void ReadOnlyStructUpdate()
+        public void Struct_ReadonlyModifier_Add()
         {
             var src1 = "struct X { }";
             var src2 = "readonly struct X { }";
@@ -1263,6 +1303,25 @@ public void ReadOnlyStructUpdate()
                 Diagnostic(RudeEditKind.ModifiersUpdate, "readonly struct X", SyntaxFacts.GetText(SyntaxKind.StructKeyword)));
         }
 
+        [Theory]
+        [InlineData("ref")]
+        [InlineData("readonly")]
+        public void Struct_Modifiers_Partial_InsertDelete(string modifier)
+        {
+            var srcA1 = modifier + " partial struct S { }";
+            var srcB1 = "partial struct S { }";
+            var srcA2 = "partial struct S { }";
+            var srcB2 = modifier + " partial struct S { }";
+
+            EditAndContinueValidation.VerifySemantics(
+                new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
+                new[]
+                {
+                    DocumentResults(),
+                    DocumentResults()
+                });
+        }
+
         [Fact]
         public void Class_ImplementingInterface_Add()
         {
@@ -1626,7 +1685,7 @@ interface I<T> { void F() {} }
         }
 
         [Fact]
-        public void Type_DeleteInsert_NonInsertableMembers()
+        public void Type_NonInsertableMembers_DeleteInsert()
         {
             var srcA1 = @"
 abstract class C
@@ -1648,6 +1707,7 @@ void F() {}
             var srcA2 = srcB1;
             var srcB2 = srcA1;
 
+            // TODO: The methods without bodies do not need to be updated.
             EditAndContinueValidation.VerifySemantics(
                 new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
                 new[]
@@ -1657,14 +1717,72 @@ void F() {}
                     DocumentResults(
                         semanticEdits: new[]
                         {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember("AbstractMethod")),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember("VirtualMethod")),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember("ToString")),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember("I.G")),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("I").GetMember("G")),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("I").GetMember("F")),
                         })
                 });
         }
 
+        [Fact]
+        public void Type_Attribute_NonInsertableMembers_DeleteInsert()
+        {
+            var srcA1 = @"
+abstract class C
+{
+    public abstract void AbstractMethod();
+    public virtual void VirtualMethod() {}
+    public override string ToString() => null;
+    public void I.G() {}
+}
+
+interface I
+{
+    void G();
+    void F() {}
+}
+";
+            var srcB1 = "";
+
+            var srcA2 = "";
+            var srcB2 = @"
+abstract class C
+{
+    [System.Obsolete]public abstract void AbstractMethod();
+    public virtual void VirtualMethod() {}
+    public override string ToString() => null;
+    public void I.G() {}
+}
+
+interface I
+{
+    [System.Obsolete]void G();
+    void F() {}
+}";
+
+            EditAndContinueValidation.VerifySemantics(
+                new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
+                new[]
+                {
+                    DocumentResults(),
+
+                    DocumentResults(
+                        semanticEdits: new[]
+                        {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember("AbstractMethod")),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember("VirtualMethod")),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember("ToString")),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember("I.G")),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("I").GetMember("G")),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("I").GetMember("F")),
+                        })
+                },
+                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities);
+        }
+
         [Fact]
         public void Type_DeleteInsert_DataMembers()
         {
@@ -1698,6 +1816,8 @@ class C
                     DocumentResults(
                         semanticEdits: new[]
                         {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<IPropertySymbol>("C.P").GetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<IPropertySymbol>("C.P").SetMethod),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").InstanceConstructors.Single(), partialType: "C", preserveLocalVariables: true),
                         })
                 });
@@ -1738,6 +1858,8 @@ partial class C
                     DocumentResults(
                         semanticEdits: new[]
                         {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<IPropertySymbol>("C.P").GetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<IPropertySymbol>("C.P").SetMethod),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").InstanceConstructors.Single(), partialType: "C", preserveLocalVariables: true),
                         })
                 });
@@ -1778,6 +1900,8 @@ class C
                     DocumentResults(
                         semanticEdits: new[]
                         {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<IPropertySymbol>("C.P").GetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<IPropertySymbol>("C.P").SetMethod),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").InstanceConstructors.Single(), partialType: "C", preserveLocalVariables: true),
                         }),
 
@@ -2001,7 +2125,7 @@ public void Record_ImplementSynthesized_PrintMembers()
             var src2 = @"
 record C
 {
-    protected bool PrintMembers(System.Text.StringBuilder builder)
+    protected virtual bool PrintMembers(System.Text.StringBuilder builder)
     {
         return true;
     }
@@ -2715,24 +2839,36 @@ public int X
         [Fact]
         public void Record_MoveProperty_Partial()
         {
-            var srcA1 = @"partial record C(int X)
+            var srcA1 = @"
+partial record C(int X)
 {
     public int Y { get; init; }
 }";
-            var srcB1 = @"partial record C;";
-            var srcA2 = @"partial record C(int X);";
-            var srcB2 = @"partial record C
+            var srcB1 = @"
+partial record C;
+";
+
+            var srcA2 = @"
+partial record C(int X);
+";
+
+            var srcB2 = @"
+partial record C
 {
     public int Y { get; init; }
 }";
 
             EditAndContinueValidation.VerifySemantics(
-                 new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
+                new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
                 new[]
                 {
                     DocumentResults(),
-
-                    DocumentResults(),
+                    DocumentResults(
+                        semanticEdits: new[]
+                        {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<IPropertySymbol>("C.Y").GetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<IPropertySymbol>("C.Y").SetMethod)
+                        }),
                 });
         }
 
@@ -2976,7 +3112,7 @@ public void EnumBaseTypeDelete()
         }
 
         [Fact]
-        public void EnumModifierUpdate()
+        public void EnumAccessibilityChange()
         {
             var src1 = "public enum Color { Red = 1, Blue = 2, }";
             var src2 = "enum Color { Red = 1, Blue = 2, }";
@@ -2986,8 +3122,18 @@ public void EnumModifierUpdate()
             edits.VerifyEdits(
                 "Update [public enum Color { Red = 1, Blue = 2, }]@0 -> [enum Color { Red = 1, Blue = 2, }]@0");
 
-            edits.VerifyRudeDiagnostics(
-                 Diagnostic(RudeEditKind.ModifiersUpdate, "enum Color", FeaturesResources.enum_));
+            edits.VerifyRudeDiagnostics(
+                 Diagnostic(RudeEditKind.ChangingAccessibility, "enum Color", FeaturesResources.enum_));
+        }
+
+        [Fact]
+        public void EnumAccessibilityNoChange()
+        {
+            var src1 = "internal enum Color { Red = 1, Blue = 2, }";
+            var src2 = "enum Color { Red = 1, Blue = 2, }";
+
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifySemantics();
         }
 
         [Fact]
@@ -3318,7 +3464,7 @@ public void Delegates_Rename()
         }
 
         [Fact]
-        public void Delegates_Update_Modifiers()
+        public void Delegates_Accessibility_Update()
         {
             var src1 = "public delegate void D();";
             var src2 = "private delegate void D();";
@@ -3329,7 +3475,7 @@ public void Delegates_Update_Modifiers()
                 "Update [public delegate void D();]@0 -> [private delegate void D();]@0");
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "private delegate void D()", FeaturesResources.delegate_));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "private delegate void D()", FeaturesResources.delegate_));
         }
 
         [Fact]
@@ -4535,101 +4681,6 @@ public void NamespaceReorder2()
 
         #region Members
 
-        [Fact]
-        public void MemberUpdate_Modifier_ReadOnly_Remove()
-        {
-            var src1 = @"
-using System;
-
-struct S
-{
-    // methods
-    public readonly int M() => 1;
-
-    // properties
-    public readonly int P => 1;
-    public readonly int Q { get; }
-    public int R { readonly get; readonly set; }
-
-    // events
-    public readonly event Action E { add {} remove {} }
-    public event Action F { readonly add {} readonly remove {} }
-}";
-            var src2 = @"
-using System;
-struct S
-{
-    // methods
-    public int M() => 1;
-
-    // properties
-    public int P => 1;
-    public int Q { get; }
-    public int R { get; set; }
-
-    // events
-    public event Action E { add {} remove {} }
-    public event Action F { add {} remove {} }
-}";
-            var edits = GetTopEdits(src1, src2);
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "public int M()", FeaturesResources.method),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "public int P", FeaturesResources.property_),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "public int Q", FeaturesResources.auto_property),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "get", CSharpFeaturesResources.property_getter),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "set", CSharpFeaturesResources.property_setter),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "add", FeaturesResources.event_accessor),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "remove", FeaturesResources.event_accessor));
-        }
-
-        [Fact]
-        public void MemberUpdate_Modifier_ReadOnly_Add()
-        {
-            var src1 = @"
-using System;
-
-struct S
-{
-    // methods
-    public int M() => 1;
-
-    // properties
-    public int P => 1;
-    public int Q { get; }
-    public int R { get; set; }
-
-    // events
-    public event Action E { add {} remove {} }
-    public event Action F { add {} remove {} }
-}";
-            var src2 = @"
-using System;
-
-struct S
-{
-    // methods
-    public readonly int M() => 1;
-
-    // properties
-    public readonly int P => 1;
-    public readonly int Q { get; }
-    public int R { readonly get; readonly set; }
-
-    // events
-    public readonly event Action E { add {} remove {} }
-    public event Action F { readonly add {} readonly remove {} }
-}";
-            var edits = GetTopEdits(src1, src2);
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "public readonly int M()", FeaturesResources.method),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "public readonly int P", FeaturesResources.property_),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "public readonly int Q", FeaturesResources.auto_property),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "readonly get", CSharpFeaturesResources.property_getter),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "readonly set", CSharpFeaturesResources.property_setter),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "readonly add", FeaturesResources.event_accessor),
-                Diagnostic(RudeEditKind.ModifiersUpdate, "readonly remove", FeaturesResources.event_accessor));
-        }
-
         [Fact]
         public void PartialMember_DeleteInsert_SingleDocument()
         {
@@ -4753,6 +4804,8 @@ event Action E { add {} remove {} }
                         semanticEdits: new[]
                         {
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IMethodSymbol>("M"), preserveLocalVariables: false),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("P1").GetMethod, preserveLocalVariables: false),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("P1").SetMethod, preserveLocalVariables: false),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("P2").GetMethod, preserveLocalVariables: false),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("P2").SetMethod, preserveLocalVariables: false),
                             SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMembers("this[]").Cast<IPropertySymbol>().Single(m => m.GetParameters().Single().Type.Name == "Int32").GetMethod, preserveLocalVariables: false),
@@ -5086,6 +5139,200 @@ public void PartialMember_DeleteInsert_ConstructorWithInitializers()
 
         #region Methods
 
+        [Theory]
+        [InlineData("static")]
+        [InlineData("virtual")]
+        [InlineData("abstract")]
+        [InlineData("override")]
+        [InlineData("sealed override", "override")]
+        public void Method_Modifiers_Update(string oldModifiers, string newModifiers = "")
+        {
+            if (oldModifiers != "")
+            {
+                oldModifiers += " ";
+            }
+
+            if (newModifiers != "")
+            {
+                newModifiers += " ";
+            }
+
+            var src1 = "class C { " + oldModifiers + "int F() => 0; }";
+            var src2 = "class C { " + newModifiers + "int F() => 0; }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [" + oldModifiers + "int F() => 0;]@10 -> [" + newModifiers + "int F() => 0;]@10");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, newModifiers + "int F()", FeaturesResources.method));
+        }
+
+        [Fact]
+        public void Method_NewModifier_Add()
+        {
+            var src1 = "class C { int F() => 0; }";
+            var src2 = "class C { new int F() => 0; }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [int F() => 0;]@10 -> [new int F() => 0;]@10");
+
+            // Currently, an edit is produced eventhough there is no metadata/IL change. Consider improving.
+            edits.VerifySemantics(
+                SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IMethodSymbol>("F")));
+        }
+
+        [Fact]
+        public void Method_NewModifier_Remove()
+        {
+            var src1 = "class C { new int F() => 0; }";
+            var src2 = "class C { int F() => 0; }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [new int F() => 0;]@10 -> [int F() => 0;]@10");
+
+            // Currently, an edit is produced eventhough there is no metadata/IL change. Consider improving.
+            edits.VerifySemantics(
+                SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IMethodSymbol>("F")));
+        }
+
+        [Fact]
+        public void Method_ReadOnlyModifier_Add_InMutableStruct()
+        {
+            var src1 = @"
+struct S
+{
+    public int M() => 1;
+}";
+            var src2 = @"
+struct S
+{
+    public readonly int M() => 1;
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "public readonly int M()", FeaturesResources.method));
+        }
+
+        [Fact]
+        public void Method_ReadOnlyModifier_Add_InReadOnlyStruct1()
+        {
+            var src1 = @"
+readonly struct S
+{
+    public int M()
+        => 1;
+}";
+            var src2 = @"
+readonly struct S
+{
+    public readonly int M()
+        => 1;
+}";
+
+            var edits = GetTopEdits(src1, src2);
+
+            // Currently, an edit is produced eventhough the body nor IsReadOnly attribute have changed. Consider improving.
+            edits.VerifySemantics(
+                SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("S").GetMember<IMethodSymbol>("M")));
+        }
+
+        [Fact]
+        public void Method_ReadOnlyModifier_Add_InReadOnlyStruct2()
+        {
+            var src1 = @"
+readonly struct S
+{
+    public int M() => 1;
+}";
+            var src2 = @"
+struct S
+{
+    public readonly int M() => 1;
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "struct S", "struct"));
+        }
+
+        [Fact]
+        public void Method_AsyncModifier_Remove()
+        {
+            var src1 = @"
+class Test
+{
+    public async Task<int> WaitAsync()
+    {
+        return 1;
+    }
+}";
+            var src2 = @"
+class Test
+{
+    public Task<int> WaitAsync()
+    {
+        return Task.FromResult(1);
+    }
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingFromAsynchronousToSynchronous, "public Task<int> WaitAsync()", FeaturesResources.method));
+        }
+
+        [Fact]
+        public void Method_AsyncModifier_Add()
+        {
+            var src1 = @"
+class Test
+{
+    public Task<int> WaitAsync()
+    {
+        return 1;
+    }
+}";
+            var src2 = @"
+class Test
+{
+    public async Task<int> WaitAsync()
+    {
+        await Task.Delay(1000);
+        return 1;
+    }
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifyRudeDiagnostics();
+
+            VerifyPreserveLocalVariables(edits, preserveLocalVariables: false);
+        }
+
+        [Fact]
+        public void Method_AsyncModifier_Add_NotSupported()
+        {
+            var src1 = @"
+class Test
+{
+    public Task<int> WaitAsync()
+    {
+        return 1;
+    }
+}";
+            var src2 = @"
+class Test
+{
+    public async Task<int> WaitAsync()
+    {
+        await Task.Delay(1000);
+        return 1;
+    }
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifyRudeDiagnostics(
+                capabilities: EditAndContinueTestHelpers.BaselineCapabilities,
+                Diagnostic(RudeEditKind.MakeMethodAsync, "public async Task<int> WaitAsync()"));
+        }
+
         [Fact]
         public void Method_Update()
         {
@@ -5581,11 +5828,56 @@ public void ExternMethodInsert()
             var src1 = @"
 using System;
 using System.Runtime.InteropServices;
-
-class C
-{
-}";
-            var src2 = @"
+
+class C
+{
+}";
+            var src2 = @"
+using System;
+using System.Runtime.InteropServices;
+
+class C
+{
+    [DllImport(""msvcrt.dll"")]
+    private static extern int puts(string c);
+}
+";
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                @"Insert [[DllImport(""msvcrt.dll"")]
+    private static extern int puts(string c);]@74",
+                "Insert [(string c)]@135",
+                "Insert [string c]@136");
+
+            // CLR doesn't support methods without a body
+            edits.VerifySemanticDiagnostics(
+                Diagnostic(RudeEditKind.InsertExtern, "private static extern int puts(string c)", FeaturesResources.method));
+        }
+
+        [Fact]
+        [WorkItem(755784, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/755784"), WorkItem(835827, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/835827")]
+        public void ExternMethodDeleteInsert()
+        {
+            var srcA1 = @"
+using System;
+using System.Runtime.InteropServices;
+
+class C
+{
+    [DllImport(""msvcrt.dll"")]
+    private static extern int puts(string c);
+}";
+            var srcA2 = @"
+using System;
+using System.Runtime.InteropServices;
+";
+
+            var srcB1 = @"
+using System;
+using System.Runtime.InteropServices;
+";
+            var srcB2 = @"
 using System;
 using System.Runtime.InteropServices;
 
@@ -5595,22 +5887,22 @@ class C
     private static extern int puts(string c);
 }
 ";
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                @"Insert [[DllImport(""msvcrt.dll"")]
-    private static extern int puts(string c);]@74",
-                "Insert [(string c)]@135",
-                "Insert [string c]@136");
-
-            // CLR doesn't support methods without a body
-            edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.InsertExtern, "private static extern int puts(string c)", FeaturesResources.method));
+            // TODO: The method does not need to be updated since there are no sequence points generated for it.
+            EditAndContinueValidation.VerifySemantics(
+                new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
+                new[]
+                {
+                    DocumentResults(),
+                    DocumentResults(semanticEdits: new[]
+                    {
+                        SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C.puts")),
+                    })
+                });
         }
 
-        [WorkItem(755784, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/755784"), WorkItem(835827, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/835827")]
         [Fact]
-        public void ExternMethodDeleteInsert()
+        [WorkItem(755784, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/755784"), WorkItem(835827, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/835827")]
+        public void ExternMethod_Attribute_DeleteInsert()
         {
             var srcA1 = @"
 using System;
@@ -5637,6 +5929,7 @@ class C
 class C
 {
     [DllImport(""msvcrt.dll"")]
+    [Obsolete]
     private static extern int puts(string c);
 }
 ";
@@ -5645,8 +5938,12 @@ class C
                 new[]
                 {
                     DocumentResults(),
-                    DocumentResults()
-                });
+                    DocumentResults(semanticEdits: new[]
+                    {
+                        SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C.puts")),
+                    })
+                },
+                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities);
         }
 
         [Fact]
@@ -5872,82 +6169,6 @@ static void Main() { }
                 Diagnostic(RudeEditKind.Delete, "static void Main()", FeaturesResources.parameter));
         }
 
-        [Fact]
-        public void MethodUpdate_Modifier_Async_Remove()
-        {
-            var src1 = @"
-class Test
-{
-    public async Task<int> WaitAsync()
-    {
-        return 1;
-    }
-}";
-            var src2 = @"
-class Test
-{
-    public Task<int> WaitAsync()
-    {
-        return Task.FromResult(1);
-    }
-}";
-            var edits = GetTopEdits(src1, src2);
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingFromAsynchronousToSynchronous, "public Task<int> WaitAsync()", FeaturesResources.method));
-        }
-
-        [Fact]
-        public void MethodUpdate_Modifier_Async_Add()
-        {
-            var src1 = @"
-class Test
-{
-    public Task<int> WaitAsync()
-    {
-        return 1;
-    }
-}";
-            var src2 = @"
-class Test
-{
-    public async Task<int> WaitAsync()
-    {
-        await Task.Delay(1000);
-        return 1;
-    }
-}";
-            var edits = GetTopEdits(src1, src2);
-            edits.VerifyRudeDiagnostics();
-
-            VerifyPreserveLocalVariables(edits, preserveLocalVariables: false);
-        }
-
-        [Fact]
-        public void MethodUpdate_Modifier_Async_Add_NotSupported()
-        {
-            var src1 = @"
-class Test
-{
-    public Task<int> WaitAsync()
-    {
-        return 1;
-    }
-}";
-            var src2 = @"
-class Test
-{
-    public async Task<int> WaitAsync()
-    {
-        await Task.Delay(1000);
-        return 1;
-    }
-}";
-            var edits = GetTopEdits(src1, src2);
-            edits.VerifyRudeDiagnostics(
-                capabilities: EditAndContinueTestHelpers.BaselineCapabilities,
-                Diagnostic(RudeEditKind.MakeMethodAsync, "public async Task<int> WaitAsync()"));
-        }
-
         [Fact]
         public void MethodUpdate_AsyncMethod0()
         {
@@ -7221,6 +7442,34 @@ public void PartialMethod_Insert()
 
         #region Operators
 
+        [Theory]
+        [InlineData("implicit", "explicit")]
+        [InlineData("explicit", "implicit")]
+        public void Operator_Modifiers_Update(string oldModifiers, string newModifiers)
+        {
+            var src1 = "class C { public static " + oldModifiers + " operator int (C c) => 0; }";
+            var src2 = "class C { public static " + newModifiers + " operator int (C c) => 0; }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [public static " + oldModifiers + " operator int (C c) => 0;]@10 -> [public static " + newModifiers + " operator int (C c) => 0;]@10");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "public static " + newModifiers + " operator int (C c)", CSharpFeaturesResources.conversion_operator));
+        }
+
+        [Fact]
+        public void Operator_Conversion_ExternModifiers_Add()
+        {
+            var src1 = "class C { public static implicit operator bool (C c) => default; }";
+            var src2 = "class C { extern public static implicit operator bool (C c); }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.MethodBodyDelete, "extern public static implicit operator bool (C c)", CSharpFeaturesResources.conversion_operator));
+        }
+
         [Fact]
         public void OperatorInsert()
         {
@@ -7494,6 +7743,23 @@ public void Operator_ReadOnlyRef_Parameter_Update()
 
         #region Constructor, Destructor
 
+        [Fact]
+        [WorkItem(2068, "https://github.com/dotnet/roslyn/issues/2068")]
+        public void Constructor_ExternModifier_Add()
+        {
+            var src1 = "class C { }";
+            var src2 = "class C { public extern C(); }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Insert [public extern C();]@10",
+                "Insert [()]@25");
+
+            // The compiler generates an empty constructor.
+            edits.VerifySemanticDiagnostics();
+        }
+
         [Fact]
         public void ConstructorInitializer_Update1()
         {
@@ -7634,7 +7900,7 @@ public void DestructorDelete_InsertConstructor()
                 "Delete [~B() { }]@10");
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "B()", FeaturesResources.constructor),
+                Diagnostic(RudeEditKind.ChangingAccessibility, "B()", FeaturesResources.constructor),
                 Diagnostic(RudeEditKind.Delete, "class B", DeletedSymbolDisplay(CSharpFeaturesResources.destructor, "~B()")));
         }
 
@@ -7682,15 +7948,15 @@ public void InstanceCtorDelete_Public()
         [InlineData("internal")]
         [InlineData("private protected")]
         [InlineData("protected internal")]
-        public void InstanceCtorDelete_NonPublic(string visibility)
+        public void InstanceCtorDelete_NonPublic(string accessibility)
         {
-            var src1 = "class C { " + visibility + " C() { } }";
+            var src1 = "class C { " + accessibility + " C() { } }";
             var src2 = "class C { }";
 
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "class C", DeletedSymbolDisplay(FeaturesResources.constructor, "C()")));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "class C", DeletedSymbolDisplay(FeaturesResources.constructor, "C()")));
         }
 
         [Fact]
@@ -7810,7 +8076,7 @@ public void InstanceCtorInsert_Private_Implicit1()
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "private C()", FeaturesResources.constructor));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "private C()", FeaturesResources.constructor));
         }
 
         [Fact]
@@ -7822,7 +8088,7 @@ public void InstanceCtorInsert_Private_Implicit2()
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "C()", FeaturesResources.constructor));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "C()", FeaturesResources.constructor));
         }
 
         [Fact]
@@ -7834,7 +8100,7 @@ public void InstanceCtorInsert_Protected_PublicImplicit()
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "protected C()", FeaturesResources.constructor));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "protected C()", FeaturesResources.constructor));
         }
 
         [Fact]
@@ -7846,7 +8112,7 @@ public void InstanceCtorInsert_Internal_PublicImplicit()
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "internal C()", FeaturesResources.constructor));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "internal C()", FeaturesResources.constructor));
         }
 
         [Fact]
@@ -7858,7 +8124,7 @@ public void InstanceCtorInsert_Internal_ProtectedImplicit()
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "internal C()", FeaturesResources.constructor));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "internal C()", FeaturesResources.constructor));
         }
 
         [Fact]
@@ -8012,12 +8278,12 @@ public void InstanceCtor_Partial_DeletePrivateInsertPublic()
                 new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
                 new[]
                 {
-                    // delete of the constructor in partial part will be reported as rude edit in the other document where it was inserted back with changed visibility
+                    // delete of the constructor in partial part will be reported as rude edit in the other document where it was inserted back with changed accessibility
                     DocumentResults(
                         semanticEdits: NoSemanticEdits),
 
                     DocumentResults(
-                        diagnostics: new[] { Diagnostic(RudeEditKind.ModifiersUpdate, "public C()", FeaturesResources.constructor) }),
+                        diagnostics: new[] { Diagnostic(RudeEditKind.ChangingAccessibility, "public C()", FeaturesResources.constructor) }),
                 });
         }
 
@@ -8155,9 +8421,9 @@ public void InstanceCtor_Partial_InsertPublicDeletePrivate()
                 new[]
                 {
                     DocumentResults(
-                        diagnostics: new[] { Diagnostic(RudeEditKind.ModifiersUpdate, "public C()", FeaturesResources.constructor) }),
+                        diagnostics: new[] { Diagnostic(RudeEditKind.ChangingAccessibility, "public C()", FeaturesResources.constructor) }),
 
-                    // delete of the constructor in partial part will be reported as rude in the the other document where it was inserted with changed visibility
+                    // delete of the constructor in partial part will be reported as rude in the the other document where it was inserted with changed accessibility
                     DocumentResults(),
                 });
         }
@@ -8176,7 +8442,7 @@ public void InstanceCtor_Partial_InsertInternalDeletePrivate()
                 new[]
                 {
                     DocumentResults(
-                        diagnostics: new[] { Diagnostic(RudeEditKind.ModifiersUpdate, "internal C()", FeaturesResources.constructor) }),
+                        diagnostics: new[] { Diagnostic(RudeEditKind.ChangingAccessibility, "internal C()", FeaturesResources.constructor) }),
 
                     DocumentResults(),
                 });
@@ -8581,23 +8847,6 @@ public void InstanceCtor_Partial_Implicit_Update()
                 });
         }
 
-        [WorkItem(2068, "https://github.com/dotnet/roslyn/issues/2068")]
-        [Fact]
-        public void Insert_ExternConstruct()
-        {
-            var src1 = "class C { }";
-            var src2 = "class C { public extern C(); }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Insert [public extern C();]@10",
-                "Insert [()]@25");
-
-            // The compiler generates an empty constructor.
-            edits.VerifySemanticDiagnostics();
-        }
-
         [Fact]
         public void ParameterlessConstructor_SemanticError_Delete1()
         {
@@ -8616,7 +8865,7 @@ class C
 
             // The compiler interprets D() as a constructor declaration.
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "class C", DeletedSymbolDisplay(FeaturesResources.constructor, "C()")));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "class C", DeletedSymbolDisplay(FeaturesResources.constructor, "C()")));
         }
 
         [Fact]
@@ -9070,7 +9319,7 @@ public void FieldInitializerUpdate_InstanceCtorUpdate_Private()
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "class C", DeletedSymbolDisplay(FeaturesResources.constructor, "C()")));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "class C", DeletedSymbolDisplay(FeaturesResources.constructor, "C()")));
         }
 
         [Fact]
@@ -9082,7 +9331,7 @@ public void PropertyInitializerUpdate_InstanceCtorUpdate_Private()
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "class C", DeletedSymbolDisplay(FeaturesResources.constructor, "C()")));
+                Diagnostic(RudeEditKind.ChangingAccessibility, "class C", DeletedSymbolDisplay(FeaturesResources.constructor, "C()")));
         }
 
         [Fact]
@@ -10469,6 +10718,109 @@ public void FieldUpdate_FieldKind()
                 Diagnostic(RudeEditKind.FieldKindUpdate, "event Action a", CSharpFeaturesResources.event_field));
         }
 
+        [Theory]
+        [InlineData("static")]
+        [InlineData("volatile")]
+        [InlineData("const")]
+        public void Field_Modifiers_Update(string oldModifiers, string newModifiers = "")
+        {
+            if (oldModifiers != "")
+            {
+                oldModifiers += " ";
+            }
+
+            if (newModifiers != "")
+            {
+                newModifiers += " ";
+            }
+
+            var src1 = "class C { " + oldModifiers + "int F = 0; }";
+            var src2 = "class C { " + newModifiers + "int F = 0; }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [" + oldModifiers + "int F = 0;]@10 -> [" + newModifiers + "int F = 0;]@10");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, newModifiers + "F = 0", FeaturesResources.field));
+        }
+
+        [Fact]
+        public void Field_Modifier_Add_InsertDelete()
+        {
+            var srcA1 = "partial class C { }";
+            var srcB1 = "partial class C { int F; }";
+
+            var srcA2 = "partial class C { static int F; }";
+            var srcB2 = "partial class C { }";
+
+            EditAndContinueValidation.VerifySemantics(
+                new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
+                new[]
+                {
+                    DocumentResults(
+                        diagnostics: new[]
+                        {
+                            Diagnostic(RudeEditKind.ModifiersUpdate, "F", FeaturesResources.field)
+                        }),
+
+                    DocumentResults(),
+                });
+        }
+
+        [Fact]
+        public void Field_Attribute_Add_InsertDelete()
+        {
+            var srcA1 = "partial class C { }";
+            var srcB1 = "partial class C { int F; }";
+
+            var srcA2 = "partial class C { [System.Obsolete]int F; }";
+            var srcB2 = "partial class C { }";
+
+            EditAndContinueValidation.VerifySemantics(
+                new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
+                new[]
+                {
+                    DocumentResults(
+                        semanticEdits: new[]
+                        {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C.F"))
+                        }),
+
+                    DocumentResults(),
+                },
+                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities);
+        }
+
+        [Fact]
+        public void Field_FixedSize_Update()
+        {
+            var src1 = "struct S { public unsafe fixed byte bs[1]; }";
+            var src2 = "struct S { public unsafe fixed byte bs[2]; }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [bs[1]]@36 -> [bs[2]]@36");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.FixedSizeFieldUpdate, "bs[2]", FeaturesResources.field));
+        }
+
+        [WorkItem(1120407, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1120407")]
+        [Fact]
+        public void Field_Const_Update()
+        {
+            var src1 = "class C { const int x = 0; }";
+            var src2 = "class C { const int x = 1; }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [x = 0]@20 -> [x = 1]@20");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.Update, "x = 1", FeaturesResources.const_field));
+        }
+
         [Fact]
         public void EventFieldUpdate_VariableDeclarator()
         {
@@ -10956,7 +11308,7 @@ public void FieldInsert_Static_NotSupportedByRuntime()
         }
 
         [Fact]
-        public void FieldUpdate_AddAttribute_Multiple()
+        public void Field_Attribute_Add_NotSupportedByRuntime()
         {
             var src1 = @"
 class C
@@ -10966,40 +11318,91 @@ class C
             var src2 = @"
 class C
 {
-    [System.Obsolete]public int a = 1, x = 1;
+    [System.Obsolete]public int a = 1, x = 1;
+}";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [public int a = 1, x = 1;]@18 -> [[System.Obsolete]public int a = 1, x = 1;]@18");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "a = 1", FeaturesResources.field));
+        }
+
+        [Fact]
+        public void Field_Attribute_Add()
+        {
+            var src1 = @"
+class C
+{
+    public int a;
+}";
+            var src2 = @"
+class C
+{
+    [System.Obsolete]public int a;
 }";
 
             var edits = GetTopEdits(src1, src2);
 
-            edits.VerifyEdits(
-                "Update [public int a = 1, x = 1;]@18 -> [[System.Obsolete]public int a = 1, x = 1;]@18");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "a = 1", FeaturesResources.field));
+            edits.VerifySemantics(
+                ActiveStatementsDescription.Empty,
+                new[]
+                {
+                    SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C.a"))
+                },
+                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities);
         }
 
         [Fact]
-        public void FieldUpdate_AddAttribute_SupportedByRuntime()
+        public void Field_Attribute_Add_WithInitializer()
         {
             var src1 = @"
 class C
 {
-    public int a;
+    int a;
 }";
             var src2 = @"
 class C
 {
-    [System.Obsolete]public int a;
+    [System.Obsolete]int a = 0;
 }";
 
             var edits = GetTopEdits(src1, src2);
 
             edits.VerifySemantics(
                 ActiveStatementsDescription.Empty,
-                new[] {
-                    SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C.a"))
+                new[]
+                {
+                    SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C.a")),
+                    SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").InstanceConstructors.Single(), preserveLocalVariables: true),
                 },
-                capabilities: EditAndContinueTestHelpers.Net5RuntimeCapabilities | EditAndContinueCapabilities.ChangeCustomAttributes);
+                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities);
+        }
+
+        [Fact]
+        public void Field_Attribute_DeleteInsertUpdate_WithInitializer()
+        {
+            var srcA1 = "partial class C { int a = 1; }";
+            var srcB1 = "partial class C { }";
+
+            var srcA2 = "partial class C { }";
+            var srcB2 = "partial class C { [System.Obsolete]int a = 2; }";
+
+            EditAndContinueValidation.VerifySemantics(
+                new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
+                new[]
+                {
+                    DocumentResults(),
+                    DocumentResults(
+                        semanticEdits: new[]
+                        {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C.a"), preserveLocalVariables: true),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").InstanceConstructors.Single(), partialType: "C", preserveLocalVariables: true)
+                        }),
+                },
+                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities);
         }
 
         [Fact]
@@ -11118,6 +11521,35 @@ public void EventField_Partial_InsertDelete()
 
         #region Properties
 
+        [Theory]
+        [InlineData("static")]
+        [InlineData("virtual")]
+        [InlineData("abstract")]
+        [InlineData("override")]
+        [InlineData("sealed override", "override")]
+        public void Property_Modifiers_Update(string oldModifiers, string newModifiers = "")
+        {
+            if (oldModifiers != "")
+            {
+                oldModifiers += " ";
+            }
+
+            if (newModifiers != "")
+            {
+                newModifiers += " ";
+            }
+
+            var src1 = "class C { " + oldModifiers + "int F => 0; }";
+            var src2 = "class C { " + newModifiers + "int F => 0; }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [" + oldModifiers + "int F => 0;]@10 -> [" + newModifiers + "int F => 0;]@10");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, newModifiers + "int F", FeaturesResources.property_));
+        }
+
         [Fact]
         public void PropertyWithExpressionBody_Update()
         {
@@ -11977,11 +12409,20 @@ public void AutoProperty_Partial_InsertDelete()
             var srcA2 = "partial class C { int P { get; set; } int Q { get; init; } }";
             var srcB2 = "partial class C { }";
 
+            // Accessors need to be updated even though they do not have an explicit body. 
+            // There is still a sequence point generated for them whose location needs to be updated.
             EditAndContinueValidation.VerifySemantics(
                 new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
                 new[]
                 {
-                    DocumentResults(),
+                    DocumentResults(
+                        semanticEdits: new[]
+                        {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("P").GetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("P").SetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("Q").GetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("Q").SetMethod),
+                        }),
                     DocumentResults(),
                 });
         }
@@ -11995,12 +12436,19 @@ public void AutoPropertyWithInitializer_Partial_InsertDelete()
             var srcA2 = "partial class C { int P { get; set; } = 1; }";
             var srcB2 = "partial class C { }";
 
+            // Accessors need to be updated even though they do not have an explicit body. 
+            // There is still a sequence point generated for them whose location needs to be updated.
             EditAndContinueValidation.VerifySemantics(
                 new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
                 new[]
                 {
                     DocumentResults(
-                        semanticEdits: new[] { SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").InstanceConstructors.Single(), partialType: "C", preserveLocalVariables: true) }),
+                        semanticEdits: new[]
+                        {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("P").GetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("P").SetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").InstanceConstructors.Single(), partialType: "C", preserveLocalVariables: true)
+                        }),
 
                     DocumentResults(),
                 });
@@ -12026,10 +12474,114 @@ public void PropertyWithExpressionBody_Partial_InsertDeleteUpdate()
                 });
         }
 
+        [Fact]
+        public void AutoProperty_ReadOnly_Add()
+        {
+            var src1 = @"
+struct S
+{
+    int P { get; }
+}";
+            var src2 = @"
+struct S
+{
+    readonly int P { get; }
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifySemanticDiagnostics();
+        }
+
+        [Fact]
+        public void Property_InMutableStruct_ReadOnly_Add()
+        {
+            var src1 = @"
+struct S
+{
+     int P1 { get => 1; }
+     int P2 { get => 1; set {}}
+     int P3 { get => 1; set {}}
+     int P4 { get => 1; set {}}
+}";
+            var src2 = @"
+struct S
+{
+     readonly int P1 { get => 1; }
+     int P2 { readonly get => 1; set {}}
+     int P3 { get => 1; readonly set {}}
+     readonly int P4 { get => 1; set {}}
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "get", CSharpFeaturesResources.property_getter),
+                Diagnostic(RudeEditKind.ModifiersUpdate, "get", CSharpFeaturesResources.property_getter),
+                Diagnostic(RudeEditKind.ModifiersUpdate, "set", CSharpFeaturesResources.property_setter),
+                Diagnostic(RudeEditKind.ModifiersUpdate, "readonly get", CSharpFeaturesResources.property_getter),
+                Diagnostic(RudeEditKind.ModifiersUpdate, "readonly set", CSharpFeaturesResources.property_setter));
+        }
+
+        [Fact]
+        public void Property_InReadOnlyStruct_ReadOnly_Add()
+        {
+            // indent to align accessor bodies and avoid updates caused by sequence point location changes
+
+            var src1 = @"
+readonly struct S
+{
+              int P1 { get => 1; }
+     int P2 {          get => 1; set {}}
+     int P3 { get => 1;          set {}}
+              int P4 { get => 1; set {}}
+}";
+            var src2 = @"
+readonly struct S
+{
+     readonly int P1 { get => 1; }
+     int P2 { readonly get => 1; set {}}
+     int P3 { get => 1; readonly set {}}
+     readonly int P4 { get => 1; set {}}
+}";
+            var edits = GetTopEdits(src1, src2);
+
+            // updates only for accessors whose modifiers were explicitly updated
+            edits.VerifySemantics(new[]
+            {
+                SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("S").GetMember<IPropertySymbol>("P2").GetMethod, preserveLocalVariables: false),
+                SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("S").GetMember<IPropertySymbol>("P3").SetMethod, preserveLocalVariables: false)
+            });
+        }
+
         #endregion
 
         #region Indexers
 
+        [Theory]
+        [InlineData("virtual")]
+        [InlineData("abstract")]
+        [InlineData("override")]
+        [InlineData("sealed override", "override")]
+        public void Indexer_Modifiers_Update(string oldModifiers, string newModifiers = "")
+        {
+            if (oldModifiers != "")
+            {
+                oldModifiers += " ";
+            }
+
+            if (newModifiers != "")
+            {
+                newModifiers += " ";
+            }
+
+            var src1 = "class C { " + oldModifiers + "int this[int a] => 0; }";
+            var src2 = "class C { " + newModifiers + "int this[int a] => 0; }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [" + oldModifiers + "int this[int a] => 0;]@10 -> [" + newModifiers + "int this[int a] => 0;]@10");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, newModifiers + "int this[int a]", FeaturesResources.indexer_));
+        }
+
         [Fact]
         public void Indexer_GetterUpdate()
         {
@@ -12694,49 +13246,6 @@ public void Indexer_Insert()
             edits.VerifySemanticDiagnostics();
         }
 
-        [WorkItem(1120407, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1120407")]
-        [Fact]
-        public void ConstField_Update()
-        {
-            var src1 = "class C { const int x = 0; }";
-            var src2 = "class C { const int x = 1; }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits("Update [x = 0]@20 -> [x = 1]@20");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.Update, "x = 1", FeaturesResources.const_field));
-        }
-
-        [Fact]
-        public void ConstField_Delete()
-        {
-            var src1 = "class C { const int x = 0; }";
-            var src2 = "class C { int x = 0; }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits("Update [const int x = 0;]@10 -> [int x = 0;]@10");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "int x = 0", FeaturesResources.field));
-        }
-
-        [Fact]
-        public void ConstField_Add()
-        {
-            var src1 = "class C { int x = 0; }";
-            var src2 = "class C { const int x = 0; }";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits("Update [int x = 0;]@10 -> [const int x = 0;]@10");
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "const int x = 0", FeaturesResources.const_field));
-        }
-
         [Fact]
         public void Indexer_ReadOnlyRef_Parameter_InsertWhole()
         {
@@ -12851,16 +13360,23 @@ public void IndexerInit_Partial_InsertDelete()
         public void AutoIndexer_Partial_InsertDelete()
         {
             var srcA1 = "partial class C { }";
-            var srcB1 = "partial class C { int this[int x] { get; set; } int Q { get; init; } }";
+            var srcB1 = "partial class C { int this[int x] { get; set; } }";
 
-            var srcA2 = "partial class C { int this[int x] { get; set; } int Q { get; init; } }";
+            var srcA2 = "partial class C { int this[int x] { get; set; } }";
             var srcB2 = "partial class C { }";
 
+            // Accessors need to be updated even though they do not have an explicit body. 
+            // There is still a sequence point generated for them whose location needs to be updated.
             EditAndContinueValidation.VerifySemantics(
                 new[] { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
                 new[]
                 {
-                    DocumentResults(),
+                    DocumentResults(
+                        semanticEdits: new[]
+                        {
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("this[]").GetMethod),
+                            SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("C").GetMember<IPropertySymbol>("this[]").SetMethod),
+                        }),
                     DocumentResults(),
                 });
         }
@@ -12897,10 +13413,116 @@ partial class C
                 });
         }
 
+        [Fact]
+        public void AutoIndexer_ReadOnly_Add()
+        {
+            var src1 = @"
+struct S
+{
+    int this[int x] { get; }
+}";
+            var src2 = @"
+struct S
+{
+    readonly int this[int x] { get; }
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifySemanticDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "get", CSharpFeaturesResources.indexer_getter));
+        }
+
+        [Fact]
+        public void Indexer_InMutableStruct_ReadOnly_Add()
+        {
+            var src1 = @"
+struct S
+{
+     int this[int x] { get => 1; }
+     int this[uint x] { get => 1; set {}}
+     int this[byte x] { get => 1; set {}}
+     int this[sbyte x] { get => 1; set {}}
+}";
+            var src2 = @"
+struct S
+{
+     readonly int this[int x] { get => 1; }
+     int this[uint x] { readonly get => 1; set {}}
+     int this[byte x] { get => 1; readonly set {}}
+     readonly int this[sbyte x] { get => 1; set {}}
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "get", CSharpFeaturesResources.indexer_getter),
+                Diagnostic(RudeEditKind.ModifiersUpdate, "get", CSharpFeaturesResources.indexer_getter),
+                Diagnostic(RudeEditKind.ModifiersUpdate, "set", CSharpFeaturesResources.indexer_setter),
+                Diagnostic(RudeEditKind.ModifiersUpdate, "readonly get", CSharpFeaturesResources.indexer_getter),
+                Diagnostic(RudeEditKind.ModifiersUpdate, "readonly set", CSharpFeaturesResources.indexer_setter));
+        }
+
+        [Fact]
+        public void Indexer_InReadOnlyStruct_ReadOnly_Add()
+        {
+            // indent to align accessor bodies and avoid updates caused by sequence point location changes
+
+            var src1 = @"
+readonly struct S
+{
+              int this[int x] { get => 1; }
+     int this[uint x] {          get => 1; set {}}
+     int this[byte x] { get => 1;          set {}}
+              int this[sbyte x] { get => 1; set {}}
+}";
+            var src2 = @"
+readonly struct S
+{
+     readonly int this[int x] { get => 1; }
+     int this[uint x] { readonly get => 1; set {}}
+     int this[byte x] { get => 1; readonly set {}}
+     readonly int this[sbyte x] { get => 1; set {}}
+}";
+            var edits = GetTopEdits(src1, src2);
+
+            // updates only for accessors whose modifiers were explicitly updated
+            edits.VerifySemantics(new[]
+            {
+                SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("S").GetMembers("this[]").Cast<IPropertySymbol>().Single(m => m.Parameters.Single().Type.Name == "UInt32").GetMethod, preserveLocalVariables: false),
+                SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("S").GetMembers("this[]").Cast<IPropertySymbol>().Single(m => m.Parameters.Single().Type.Name == "Byte").SetMethod, preserveLocalVariables: false)
+            });
+        }
+
         #endregion
 
         #region Events
 
+        [Theory]
+        [InlineData("static")]
+        [InlineData("virtual")]
+        [InlineData("abstract")]
+        [InlineData("override")]
+        [InlineData("sealed override", "override")]
+        public void Event_Modifiers_Update(string oldModifiers, string newModifiers = "")
+        {
+            if (oldModifiers != "")
+            {
+                oldModifiers += " ";
+            }
+
+            if (newModifiers != "")
+            {
+                newModifiers += " ";
+            }
+
+            var src1 = "class C { " + oldModifiers + "event Action F { add {} remove {} } }";
+            var src2 = "class C { " + newModifiers + "event Action F { add {} remove {} } }";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits("Update [" + oldModifiers + "event Action F { add {} remove {} }]@10 -> [" + newModifiers + "event Action F { add {} remove {} }]@10");
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, newModifiers + "event Action F", FeaturesResources.event_));
+        }
+
         [Fact]
         public void EventAccessorReorder1()
         {
@@ -13074,6 +13696,45 @@ public void Event_Partial_InsertDelete()
                 });
         }
 
+        [Fact]
+        public void Event_InMutableStruct_ReadOnly_Add()
+        {
+            var src1 = @"
+struct S
+{
+    public event Action E { add {} remove {} }
+}";
+            var src2 = @"
+struct S
+{
+    public readonly event Action E { add {} remove {} }
+}";
+            var edits = GetTopEdits(src1, src2);
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "public readonly event Action E", FeaturesResources.event_));
+        }
+
+        [Fact]
+        public void Event_InReadOnlyStruct_ReadOnly_Add1()
+        {
+            var src1 = @"
+readonly struct S
+{
+    public event Action E { add {} remove {} }
+}";
+            var src2 = @"
+readonly struct S
+{
+    public readonly event Action E { add {} remove {} }
+}";
+            var edits = GetTopEdits(src1, src2);
+
+            // Currently, an edit is produced eventhough bodies nor IsReadOnly attribute have changed. Consider improving.
+            edits.VerifySemantics(
+                SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("S").GetMember<IEventSymbol>("E").AddMethod),
+                SemanticEdit(SemanticEditKind.Update, c => c.GetMember<INamedTypeSymbol>("S").GetMember<IEventSymbol>("E").RemoveMethod));
+        }
+
         #endregion
 
         #region Parameter
diff --git a/src/EditorFeatures/CSharpTest/EditorConfigSettings/DataProvider/DataProviderTests.cs b/src/EditorFeatures/CSharpTest/EditorConfigSettings/DataProvider/DataProviderTests.cs
index 66842a26d5565..5bc456ab6687f 100644
--- a/src/EditorFeatures/CSharpTest/EditorConfigSettings/DataProvider/DataProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditorConfigSettings/DataProvider/DataProviderTests.cs
@@ -108,7 +108,7 @@ public void TestGettingCodeStyleSettingsProviderLanguageServiceAsync()
             var model = new TestViewModel();
             settingsProvider.RegisterViewModel(model);
             var dataSnapShot = settingsProvider.GetCurrentDataSnapshot();
-            Assert.Equal(29, dataSnapShot.Length);
+            Assert.Equal(30, dataSnapShot.Length);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.EditorConfigUI)]
diff --git a/src/EditorFeatures/CSharpTest/GenerateFromMembers/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.cs b/src/EditorFeatures/CSharpTest/GenerateFromMembers/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.cs
index 792917787cdca..bcb254453e86a 100644
--- a/src/EditorFeatures/CSharpTest/GenerateFromMembers/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.cs
+++ b/src/EditorFeatures/CSharpTest/GenerateFromMembers/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.cs
@@ -35,7 +35,7 @@ private class TestWithDialog : VerifyCS.Test
             public ImmutableArray<string> MemberNames;
             public Action<ImmutableArray<PickMembersOption>> OptionsCallback;
 
-            public override AdhocWorkspace CreateWorkspace()
+            protected override Workspace CreateWorkspaceImpl()
             {
                 // If we're a dialog test, then mixin our mock and initialize its values to the ones the test asked for.
                 var workspace = new AdhocWorkspace(s_composition.GetHostServices());
@@ -98,15 +98,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [WorkItem(39916, "https://github.com/dotnet/roslyn/issues/39916")]
@@ -135,15 +133,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferExplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferExplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -179,15 +175,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -229,15 +223,13 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -273,15 +265,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -309,15 +299,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -345,15 +333,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -386,15 +372,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -426,15 +410,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -484,16 +466,14 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 0,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -551,15 +531,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -795,15 +773,13 @@ public override bool Equals(object obj)
 }
 ";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = expected,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -860,16 +836,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -902,16 +876,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -955,16 +927,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1005,17 +975,15 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 MemberNames = ImmutableArray<string>.Empty,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1088,16 +1056,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1130,16 +1096,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1180,16 +1144,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1374,16 +1336,14 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 0,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1411,15 +1371,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1447,15 +1405,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1488,16 +1444,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1530,16 +1484,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1580,16 +1532,14 @@ struct Bar
 {
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1632,16 +1582,14 @@ struct Bar
     public override int GetHashCode() => 0;
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1682,16 +1630,14 @@ struct Bar
 {
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1724,16 +1670,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1766,16 +1710,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1816,16 +1758,14 @@ enum Bar
 {
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1858,16 +1798,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1899,16 +1837,14 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = ImmutableArray.Create("a", "b"),
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1942,16 +1878,14 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = ImmutableArray.Create("c", "b"),
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -1983,16 +1917,14 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = ImmutableArray<string>.Empty,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [WorkItem(17643, "https://github.com/dotnet/roslyn/issues/17643")]
@@ -2020,15 +1952,13 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [WorkItem(25690, "https://github.com/dotnet/roslyn/issues/25690")]
@@ -2188,17 +2118,15 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = default,
                 OptionsCallback = options => EnableOption(options, GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.GenerateOperatorsId),
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -2278,17 +2206,15 @@ public override bool Equals(object obj)
     public static bool operator {|CS0216:==|}(Program left, Program right) => true;
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = default,
                 OptionsCallback = options => Assert.Null(options.FirstOrDefault(i => i.Id == GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.GenerateOperatorsId)),
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -2333,17 +2259,15 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = default,
                 OptionsCallback = options => EnableOption(options, GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.GenerateOperatorsId),
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -2392,16 +2316,14 @@ enum Bar
 {
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 0,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -2466,16 +2388,14 @@ struct Bar : IEquatable<Bar>
     public static bool operator !=(Bar left, Bar right) => !(left == right);
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 0,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -2510,17 +2430,15 @@ public bool Equals(Program other)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = default,
                 OptionsCallback = options => EnableOption(options, GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.ImplementIEquatableId),
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -2711,17 +2629,15 @@ public bool Equals(Program other)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = default,
                 OptionsCallback = options => EnableOption(options, GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.ImplementIEquatableId),
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -2844,17 +2760,15 @@ public override bool Equals(object obj)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = default,
                 OptionsCallback = options => Assert.Null(options.FirstOrDefault(i => i.Id == GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.ImplementIEquatableId)),
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -3063,16 +2977,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -3121,7 +3033,7 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedState =
@@ -3135,10 +3047,8 @@ public override int GetHashCode()
                 },
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [WorkItem(37297, "https://github.com/dotnet/roslyn/issues/37297")]
@@ -3186,7 +3096,7 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestState =
                 {
@@ -3211,10 +3121,8 @@ public override int GetHashCode()
                 },
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [WorkItem(37297, "https://github.com/dotnet/roslyn/issues/37297")]
@@ -3262,7 +3170,7 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestState =
                 {
@@ -3279,10 +3187,8 @@ public override int GetHashCode()
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -3338,7 +3244,7 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedState =
@@ -3352,10 +3258,8 @@ public override int GetHashCode()
                 },
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -3422,16 +3326,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [WorkItem(39916, "https://github.com/dotnet/roslyn/issues/39916")]
@@ -3499,16 +3401,14 @@ public override int GetHashCode()
     }
 }";
 
-            var test = new VerifyCS.Test
+            await new VerifyCS.Test
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 CodeActionIndex = 1,
                 LanguageVersion = LanguageVersion.CSharp6,
-            };
-
-            test.Options.AddRange(PreferExplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferExplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
@@ -3693,7 +3593,7 @@ public override bool Equals(object? obj)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedState =
@@ -3710,10 +3610,8 @@ public override bool Equals(object? obj)
                 MemberNames = default,
                 OptionsCallback = options => EnableOption(options, GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.GenerateOperatorsId),
                 LanguageVersion = LanguageVersion.Default,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [WorkItem(40053, "https://github.com/dotnet/roslyn/issues/40053")]
@@ -3761,17 +3659,15 @@ public override bool Equals(object? obj)
     }
 }";
 
-            var test = new TestWithDialog
+            await new TestWithDialog
             {
                 TestCode = code,
                 FixedCode = fixedCode,
                 MemberNames = default,
                 OptionsCallback = options => EnableOption(options, GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.GenerateOperatorsId),
                 LanguageVersion = LanguageVersion.Default,
-            };
-
-            test.Options.AddRange(PreferImplicitTypeWithInfo());
-            await test.RunAsync();
+                Options = { PreferImplicitTypeWithInfo() },
+            }.RunAsync();
         }
 
         [WorkItem(42574, "https://github.com/dotnet/roslyn/issues/42574")]
diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementExplicitlyTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementExplicitlyTests.cs
index 7e7b0806bdaea..511f26564b02e 100644
--- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementExplicitlyTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementExplicitlyTests.cs
@@ -15,7 +15,7 @@
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ImplementInterface
 {
-    public partial class ImplementExplicitlyTests : AbstractCSharpCodeActionTest
+    public class ImplementExplicitlyTests : AbstractCSharpCodeActionTest
     {
         private const int SingleMember = 0;
         private const int SameInterface = 1;
diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementImplicitlyTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementImplicitlyTests.cs
index 9e5cf1cf288a1..d46a05aa7684a 100644
--- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementImplicitlyTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementImplicitlyTests.cs
@@ -16,7 +16,7 @@
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ImplementInterface
 {
-    public partial class ImplementImplicitlyTests : AbstractCSharpCodeActionTest
+    public class ImplementImplicitlyTests : AbstractCSharpCodeActionTest
     {
         private const int SingleMember = 0;
         private const int SameInterface = 1;
diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
index 433012586fa24..c8065add4eb18 100644
--- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
@@ -3,37 +3,27 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.ImplementInterface;
-using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.NamingStyles;
 using Microsoft.CodeAnalysis.ImplementType;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.Testing;
 using Roslyn.Test.Utilities;
 using Xunit;
-using Xunit.Abstractions;
+using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeFixVerifier<
+    Microsoft.CodeAnalysis.Testing.EmptyDiagnosticAnalyzer,
+    Microsoft.CodeAnalysis.CSharp.ImplementInterface.CSharpImplementInterfaceCodeFixProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ImplementInterface
 {
-    public partial class ImplementInterfaceTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
+    public class ImplementInterfaceTests
     {
         private readonly NamingStylesTestOptionSets _options = new NamingStylesTestOptionSets(LanguageNames.CSharp);
 
-        public ImplementInterfaceTests(ITestOutputHelper logger)
-          : base(logger)
-        {
-        }
-
-        internal override (DiagnosticAnalyzer?, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
-            => (null, new CSharpImplementInterfaceCodeFixProvider());
-
-        private OptionsCollection AllOptionsOff
-            => new OptionsCollection(GetLanguage())
+        private static OptionsCollection AllOptionsOff
+            => new OptionsCollection(LanguageNames.CSharp)
             {
                  { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
                  { CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
@@ -43,8 +33,8 @@ private OptionsCollection AllOptionsOff
                  { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
             };
 
-        private OptionsCollection AllOptionsOn
-            => new OptionsCollection(GetLanguage())
+        private static OptionsCollection AllOptionsOn
+            => new OptionsCollection(LanguageNames.CSharp)
             {
                  { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
                  { CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
@@ -54,8 +44,8 @@ private OptionsCollection AllOptionsOn
                  { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
             };
 
-        private OptionsCollection AccessorOptionsOn
-            => new OptionsCollection(GetLanguage())
+        private static OptionsCollection AccessorOptionsOn
+            => new OptionsCollection(LanguageNames.CSharp)
             {
                  { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
                  { CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
@@ -65,77 +55,52 @@ private OptionsCollection AccessorOptionsOn
                  { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
             };
 
-        private static readonly ParseOptions CSharp7_1 = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_1);
-
-        private const string NullableAttributesCode = @"
-namespace System.Diagnostics.CodeAnalysis
-{
-    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)]
-    internal sealed class AllowNullAttribute : Attribute { }
-
-    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)]
-    internal sealed class DisallowNullAttribute : Attribute { }
-
-    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
-    internal sealed class MaybeNullAttribute : Attribute { }
-
-    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
-    internal sealed class NotNullAttribute : Attribute { }
-
-    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
-    internal sealed class MaybeNullWhenAttribute : Attribute
-    {
-        public MaybeNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
-        public bool ReturnValue { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
-    internal sealed class NotNullWhenAttribute : Attribute
-    {
-        public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
-        public bool ReturnValue { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
-    internal sealed class NotNullIfNotNullAttribute : Attribute
-    {
-        public NotNullIfNotNullAttribute(string parameterName) => ParameterName = parameterName;
-        public string ParameterName { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
-    internal sealed class DoesNotReturnAttribute : Attribute { }
-
-    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
-    internal sealed class DoesNotReturnIfAttribute : Attribute
-    {
-        public DoesNotReturnIfAttribute(bool parameterValue) => ParameterValue = parameterValue;
-        public bool ParameterValue { get; }
-    }
-}";
-
-        internal async Task TestWithAllCodeStyleOptionsOffAsync(
+        internal static async Task TestWithAllCodeStyleOptionsOffAsync(
             string initialMarkup, string expectedMarkup,
-            int index = 0, ParseOptions? parseOptions = null)
+            (string equivalenceKey, int index)? codeAction = null)
         {
-            await TestAsync(initialMarkup, expectedMarkup, parseOptions, null,
-                index, options: AllOptionsOff);
+            await new VerifyCS.Test
+            {
+                TestCode = initialMarkup,
+                FixedCode = expectedMarkup,
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = codeAction?.equivalenceKey,
+                CodeActionIndex = codeAction?.index,
+            }.RunAsync();
         }
 
-        internal async Task TestWithAllCodeStyleOptionsOnAsync(
-            string initialMarkup, string expectedMarkup,
-            int index = 0, ParseOptions? parseOptions = null)
+        internal static async Task TestWithAllCodeStyleOptionsOnAsync(string initialMarkup, string expectedMarkup)
         {
-            await TestAsync(initialMarkup, expectedMarkup, parseOptions, null,
-                index, options: AllOptionsOn);
+            await new VerifyCS.Test
+            {
+                TestCode = initialMarkup,
+                FixedCode = expectedMarkup,
+                Options = { AllOptionsOn },
+            }.RunAsync();
         }
 
-        internal async Task TestWithAccessorCodeStyleOptionsOnAsync(
-            string initialMarkup, string expectedMarkup,
-            int index = 0, ParseOptions? parseOptions = null)
+        internal static async Task TestWithAccessorCodeStyleOptionsOnAsync(string initialMarkup, string expectedMarkup)
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = initialMarkup,
+                FixedCode = expectedMarkup,
+                Options = { AccessorOptionsOn },
+            }.RunAsync();
+        }
+
+        private static async Task TestInRegularAndScriptAsync(
+            string initialMarkup,
+            string expectedMarkup,
+            (string equivalenceKey, int index)? codeAction = null)
         {
-            await TestAsync(initialMarkup, expectedMarkup, parseOptions, null,
-                index, options: AccessorOptionsOn);
+            await new VerifyCS.Test
+            {
+                TestCode = initialMarkup,
+                FixedCode = expectedMarkup,
+                CodeActionEquivalenceKey = codeAction?.equivalenceKey,
+                CodeActionIndex = codeAction?.index,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -147,7 +112,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1();
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
 @"interface IInterface
@@ -167,16 +132,18 @@ public void Method1()
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestMethodInRecord()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"interface IInterface
 {
     void Method1();
 }
 
-record Record : [|IInterface|]
+record Record : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 }
@@ -187,7 +154,8 @@ public void Method1()
     {
         throw new System.NotImplementedException();
     }
-}", parseOptions: TestOptions.RegularPreview);
+}",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -210,19 +178,21 @@ public NativeIntegerAttribute(bool[] flags)
 }";
 
             // Note: we're putting the attribute by hand to simulate metadata
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.CSharp9,
+                TestCode = @"interface IInterface
 {
-    [return: System.Runtime.CompilerServices.NativeInteger(new[] { true, true })]
+    [return: {|CS8335:System.Runtime.CompilerServices.NativeInteger(new[] { true, true })|}]
     (nint, nuint) Method(nint x, nuint x2);
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }" + nativeIntegerAttributeDefinition,
-    @"interface IInterface
+                FixedCode = @"interface IInterface
 {
-    [return: System.Runtime.CompilerServices.NativeInteger(new[] { true, true })]
+    [return: {|CS8335:System.Runtime.CompilerServices.NativeInteger(new[] { true, true })|}]
     (nint, nuint) Method(nint x, nuint x2);
 }
 
@@ -232,7 +202,9 @@ class Class : IInterface
     {
         throw new System.NotImplementedException();
     }
-}" + nativeIntegerAttributeDefinition);
+}" + nativeIntegerAttributeDefinition,
+                Options = { AllOptionsOff },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -244,7 +216,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     (int, int) Method((string, string) x);
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
 @"interface IInterface
@@ -272,7 +244,7 @@ interface I
 {
     ValueTuple<object> F();
 }
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"
@@ -299,7 +271,7 @@ await TestWithAllCodeStyleOptionsOnAsync(
     void Method1();
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
 @"interface IInterface
@@ -313,14 +285,6 @@ class Class : IInterface
 }");
         }
 
-        private const string s_tupleElementNamesAttribute =
-@"namespace System.Runtime.CompilerServices
-{
-    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Event )]
-    public sealed class TupleElementNamesAttribute : Attribute { }
-}
-";
-
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface), CompilerTrait(CompilerFeature.Tuples)]
         public async Task TupleWithNamesInMethod()
         {
@@ -328,16 +292,16 @@ public async Task TupleWithNamesInMethod()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"interface IInterface
 {
-    [return: System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })]
+    [return: {|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}]
     (int a, int b)[] Method1((int c, string) x);
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
-}" + s_tupleElementNamesAttribute,
+}",
 @"interface IInterface
 {
-    [return: System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })]
+    [return: {|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}]
     (int a, int b)[] Method1((int c, string) x);
 }
 
@@ -347,8 +311,7 @@ class Class : IInterface
     {
         throw new System.NotImplementedException();
     }
-}
-" + s_tupleElementNamesAttribute);
+}");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface), CompilerTrait(CompilerFeature.Tuples)]
@@ -357,16 +320,16 @@ public async Task TupleWithNamesInMethod_Explicitly()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"interface IInterface
 {
-    [return: System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })]
+    [return: {|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}]
     (int a, int b)[] Method1((int c, string) x);
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
-}" + s_tupleElementNamesAttribute,
+}",
 @"interface IInterface
 {
-    [return: System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })]
+    [return: {|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}]
     (int a, int b)[] Method1((int c, string) x);
 }
 
@@ -376,9 +339,8 @@ class Class : IInterface
     {
         throw new System.NotImplementedException();
     }
-}
-" + s_tupleElementNamesAttribute,
-index: 1);
+}",
+codeAction: ("True;False;False:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface), CompilerTrait(CompilerFeature.Tuples)]
@@ -387,17 +349,17 @@ public async Task TupleWithNamesInProperty()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"interface IInterface
 {
-    [System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })]
-    (int a, int b)[] Property1 { [System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })] get; [System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })] set; }
+    [{|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}]
+    (int a, int b)[] Property1 { [return: {|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}] get; [param: {|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}] set; }
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
-}" + s_tupleElementNamesAttribute,
+}",
 @"interface IInterface
 {
-    [System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })]
-    (int a, int b)[] Property1 { [System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })] get; [System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })] set; }
+    [{|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}]
+    (int a, int b)[] Property1 { [return: {|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}] get; [param: {|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}] set; }
 }
 
 class Class : IInterface
@@ -414,34 +376,37 @@ class Class : IInterface
             throw new System.NotImplementedException();
         }
     }
-}
-" + s_tupleElementNamesAttribute);
+}");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface), CompilerTrait(CompilerFeature.Tuples)]
         public async Task TupleWithNamesInEvent()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface IInterface
 {
-    [System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })]
-    event Func<(int a, int b)> Event1;
+    [{|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}]
+    event System.Func<(int a, int b)> Event1;
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
-}" + s_tupleElementNamesAttribute,
-@"interface IInterface
+}",
+                FixedCode = @"using System;
+
+interface IInterface
 {
-    [System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })]
-    event Func<(int a, int b)> Event1;
+    [{|CS8138:System.Runtime.CompilerServices.TupleElementNames(new[] { ""a"", ""b"" })|}]
+    event System.Func<(int a, int b)> Event1;
 }
 
 class Class : IInterface
 {
     public event Func<(int a, int b)> Event1;
-}
-" + s_tupleElementNamesAttribute);
+}",
+                Options = { AllOptionsOff },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -450,16 +415,16 @@ public async Task NoDynamicAttributeInMethod()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"interface IInterface
 {
-    [return: System.Runtime.CompilerServices.DynamicAttribute()]
+    [return: {|CS1970:System.Runtime.CompilerServices.DynamicAttribute()|}]
     object Method1();
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
 @"interface IInterface
 {
-    [return: System.Runtime.CompilerServices.DynamicAttribute()]
+    [return: {|CS1970:System.Runtime.CompilerServices.DynamicAttribute()|}]
     object Method1();
 }
 
@@ -475,32 +440,48 @@ public object Method1()
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task NoNullableAttributesInMethodFromMetadata()
         {
-            var initial = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <MetadataReferenceFromSource Language=""C#"" CommonReferences=""true"">
-            <Document>
-#nullable enable
-
-public interface IInterface
-{
-    void M(string? s1, string s2);
-    string this[string? s1, string s2] { get; set; }
-}
-            </Document>
-        </MetadataReferenceFromSource>
-        <Document>
+            var test = new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"
 #nullable enable
 
 using System;
 
-class C : [|IInterface|]
+class C : {|CS0535:{|CS0535:IInterface|}|}
 {
-}</Document>
-    </Project>
-</Workspace>";
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"
+#nullable enable
 
-            var expected = @"
+public interface IInterface
+{
+    void M(string? s1, string s2);
+    string this[string? s1, string s2] { get; set; }
+}"
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences =
+                    {
+                        "Assembly1",
+                    },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"
 #nullable enable
 
 using System;
@@ -524,9 +505,15 @@ public void M(string? s1, string s2)
     {
         throw new NotImplementedException();
     }
-}";
+}",
+                    },
+                },
+                CodeActionEquivalenceKey = "False;False;True:global::IInterface;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            };
 
-            await TestWithAllCodeStyleOptionsOffAsync(initial, expected, index: 0);
+            test.Options.AddRange(AllOptionsOff);
+            await test.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -538,7 +525,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1();
 }
 
-class Class : [|IInterface|]",
+class Class : {|CS0535:IInterface|}{|CS1513:|}{|CS1514:|}",
 @"interface IInterface
 {
     void Method1();
@@ -567,7 +554,7 @@ interface IInterface2 : IInterface1
 {
 }
 
-class Class : [|IInterface2|]
+class Class : {|CS0535:IInterface2|}
 {
 }",
 @"interface IInterface1
@@ -601,7 +588,7 @@ interface IInterface2 : IInterface1
     void Method1();
 }
 
-class Class : [|IInterface2|]
+class Class : {|CS0535:IInterface2|}
 {
 }",
 @"interface IInterface1
@@ -636,7 +623,7 @@ interface IInterface2 : IInterface1
     void Method2();
 }
 
-class Class : [|IInterface2|]
+class Class : {|CS0535:{|CS0535:IInterface2|}|}
 {
 }",
 @"interface IInterface1
@@ -677,7 +664,7 @@ interface IInterface2 : IInterface1
     void Method1();
 }
 
-class Class : [|IInterface2|]
+class Class : {|CS0535:{|CS0535:IInterface2|}|}
 {
 }",
 @"interface IInterface1
@@ -708,7 +695,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1();
 }
 
-class Class : [|IInterface1|]
+class Class : {|CS0738:IInterface1|}
 {
     public int Method1()
     {
@@ -743,7 +730,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1(int i);
 }
 
-class Class : [|IInterface1|]
+class Class : {|CS0535:IInterface1|}
 {
     public void Method1(string i)
     {
@@ -776,7 +763,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1(T t);
 }
 
-class Class : [|IInterface1<int>|]
+class Class : {|CS0535:IInterface1<int>|}
 {
 }",
 @"interface IInterface1<T>
@@ -802,7 +789,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1<U>(T t, U u);
 }
 
-class Class : [|IInterface1<int>|]
+class Class : {|CS0535:IInterface1<int>|}
 {
 }",
 @"interface IInterface1<T>
@@ -823,15 +810,17 @@ public void Method1<U>(int t, U u)
         public async Task TestImplementGenericTypeWithGenericMethodWithNaturalConstraint()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface1<T>
+@"using System.Collections.Generic;
+interface IInterface1<T>
 {
     void Method1<U>(T t, U u) where U : IList<T>;
 }
 
-class Class : [|IInterface1<int>|]
+class Class : {|CS0535:IInterface1<int>|}
 {
 }",
-@"interface IInterface1<T>
+@"using System.Collections.Generic;
+interface IInterface1<T>
 {
     void Method1<U>(T t, U u) where U : IList<T>;
 }
@@ -854,7 +843,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1<U>(T t, U u) where U : T;
 }
 
-class Class : [|IInterface1<int>|]
+class Class : {|CS0535:IInterface1<int>|}
 {
 }",
 @"interface IInterface1<T>
@@ -880,7 +869,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     string[] M();
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -906,7 +895,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1();
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
     I i;
 }",
@@ -924,7 +913,7 @@ public void Method1()
         i.Method1();
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;i", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -936,12 +925,12 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1();
 }
 
-class C : {|FixAllInDocument:I|}
+class C : {|CS0535:I|}
 {
     I i;
 }
 
-class D : I
+class D : {|CS0535:I|}
 {
     I i;
 }",
@@ -969,7 +958,7 @@ public void Method1()
         i.Method1();
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;i", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -981,12 +970,12 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1();
 }
 
-class C : {|FixAllInDocument:I|}
+class C : {|CS0535:I|}
 {
     I i;
 }
 
-class D : I
+class D : {|CS0535:I|}
 {
     I i { get; }
 }",
@@ -1014,28 +1003,33 @@ public void Method1()
         i.Method1();
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;i", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementThroughFieldMember_FixAll_FieldInOneNonViableInAnother()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
+            var test = new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     void Method1();
 }
 
-class C : {|FixAllInDocument:I|}
+class C : {|CS0535:I|}
 {
     I i;
 }
 
-class D : I
+class D : {|CS0535:I|}
 {
     int i;
 }",
-@"interface I
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface I
 {
     void Method1();
 }
@@ -1050,11 +1044,20 @@ public void Method1()
     }
 }
 
-class D : I
+class D : {|CS0535:I|}
 {
     int i;
 }",
-index: 1);
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne,
+                CodeActionEquivalenceKey = "False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;i",
+                CodeActionIndex = 1,
+            };
+
+            test.Options.AddRange(AllOptionsOff);
+            await test.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -1066,7 +1069,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int this[int x] { get; set; }
 }
 
-class Goo : [|IGoo|]
+class Goo : {|CS0535:IGoo|}
 {
     IGoo f;
 }",
@@ -1092,7 +1095,7 @@ public int this[int x]
         }
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::IGoo;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;f", 1));
         }
 
         [WorkItem(472, "https://github.com/dotnet/roslyn/issues/472")]
@@ -1102,7 +1105,7 @@ public async Task TestImplementThroughFieldMemberRemoveUnnecessaryCast()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System.Collections;
 
-sealed class X : [|IComparer|]
+sealed class X : {|CS0535:IComparer|}
 {
     X x;
 }",
@@ -1117,7 +1120,7 @@ public int Compare(object x, object y)
         return ((IComparer)this.x).Compare(x, y);
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::System.Collections.IComparer;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;x", 1));
         }
 
         [WorkItem(472, "https://github.com/dotnet/roslyn/issues/472")]
@@ -1127,7 +1130,7 @@ public async Task TestImplementThroughFieldMemberRemoveUnnecessaryCastAndThis()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System.Collections;
 
-sealed class X : [|IComparer|]
+sealed class X : {|CS0535:IComparer|}
 {
     X a;
 }",
@@ -1142,7 +1145,7 @@ public int Compare(object x, object y)
         return ((IComparer)a).Compare(x, y);
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::System.Collections.IComparer;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;a", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -1154,7 +1157,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Method1();
 }
 
-abstract class C : [|I|]
+abstract class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -1166,14 +1169,14 @@ abstract class C : I
 {
     public abstract void Method1();
 }",
-index: 1);
+codeAction: ("False;True;True:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementInterfaceWithRefOutParameters()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
-@"class C : [|I|]
+@"class C : {|CS0535:{|CS0535:I|}|}
 {
     I goo;
 }
@@ -1203,7 +1206,7 @@ interface I
     void Method1(ref int x, out int y, int z);
     int Method2();
 }",
-index: 1);
+codeAction: ("False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;goo", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -1214,10 +1217,11 @@ await TestWithAllCodeStyleOptionsOffAsync(
 {
     public int Method1()
     {
+        return 0;
     }
 }
 
-class C : B, [|I|]
+class C : B, {|CS0738:I|}
 {
 }
 
@@ -1229,6 +1233,7 @@ interface I
 {
     public int Method1()
     {
+        return 0;
     }
 }
 
@@ -1250,7 +1255,7 @@ interface I
         public async Task TestConflictingProperties()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
-@"class Test : [|I1|]
+@"class Test : {|CS0737:I1|}
 {
     int Prop { get; set; }
 }
@@ -1287,13 +1292,13 @@ interface I1
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestExplicitProperties()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"interface I2
 {
     decimal Calc { get; }
 }
 
-class C : [|I2|]
+class C : I2
 {
     protected decimal pay;
 
@@ -1304,7 +1309,9 @@ decimal I2.Calc
             return pay;
         }
     }
-}");
+}";
+
+            await VerifyCS.VerifyCodeFixAsync(code, code);
         }
 
         [WorkItem(539489, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539489")]
@@ -1317,7 +1324,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void @M();
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
 @"interface IInterface
@@ -1344,7 +1351,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void @int();
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
 @"interface IInterface
@@ -1371,9 +1378,9 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void M();
 }
 
-class Class : [|@IInterface|]
+class Class : {|CS0737:@IInterface|}
 {
-    string M();
+    string M() => """";
 }",
 @"interface @IInterface
 {
@@ -1382,7 +1389,7 @@ class Class : [|@IInterface|]
 
 class Class : @IInterface
 {
-    string M();
+    string M() => """";
 
     void IInterface.M()
     {
@@ -1401,9 +1408,9 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void @M();
 }
 
-class Class : [|@IInterface|]
+class Class : {|CS0737:@IInterface|}
 {
-    string M();
+    string M() => """";
 }",
 @"interface @IInterface
 {
@@ -1412,7 +1419,7 @@ class Class : [|@IInterface|]
 
 class Class : @IInterface
 {
-    string M();
+    string M() => """";
 
     void IInterface.M()
     {
@@ -1431,9 +1438,9 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void M();
 }
 
-class Class : [|@int|]
+class Class : {|CS0737:@int|}
 {
-    string M();
+    string M() => """";
 }",
 @"interface @int
 {
@@ -1442,7 +1449,7 @@ class Class : [|@int|]
 
 class Class : @int
 {
-    string M();
+    string M() => """";
 
     void @int.M()
     {
@@ -1461,9 +1468,9 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void @bool();
 }
 
-class Class : [|@int|]
+class Class : {|CS0737:@int|}
 {
-    string @bool();
+    string @bool() => """";
 }",
 @"interface @int
 {
@@ -1472,7 +1479,7 @@ class Class : [|@int|]
 
 class Class : @int
 {
-    string @bool();
+    string @bool() => """";
 
     void @int.@bool()
     {
@@ -1490,7 +1497,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
 {
     int Prop { get; set; }
 }
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1523,7 +1530,7 @@ await TestWithAllCodeStyleOptionsOnAsync(
     int Prop { get; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1546,7 +1553,7 @@ await TestWithAccessorCodeStyleOptionsOnAsync(
     int Prop { get; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1569,7 +1576,7 @@ await TestWithAllCodeStyleOptionsOnAsync(
     int this[int i] { get; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1592,7 +1599,7 @@ await TestWithAccessorCodeStyleOptionsOnAsync(
     int this[int i] { get; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1615,7 +1622,7 @@ await TestWithAllCodeStyleOptionsOnAsync(
     int M();
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1638,7 +1645,7 @@ await TestWithAllCodeStyleOptionsOnAsync(
 {
     int Prop { get; }
 }
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1661,7 +1668,7 @@ await TestWithAccessorCodeStyleOptionsOnAsync(
     int Prop { get; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1685,7 +1692,7 @@ await TestWithAccessorCodeStyleOptionsOnAsync(
     int Prop { get; set; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1709,7 +1716,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int Prop { get; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1738,7 +1745,7 @@ await TestWithAllCodeStyleOptionsOnAsync(
     int this[int i] { get; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1761,7 +1768,7 @@ await TestWithAllCodeStyleOptionsOnAsync(
     int this[int i] { get; set; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1784,7 +1791,7 @@ await TestWithAccessorCodeStyleOptionsOnAsync(
     int this[int i] { get; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1807,7 +1814,7 @@ await TestWithAllCodeStyleOptionsOnAsync(
     int this[int i] { get; set; }
 }
 
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
 }",
 @"public interface DD
@@ -1829,7 +1836,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
 {
     void Goo();
 }
-public class A : [|DD|]
+public class A : {|CS0535:DD|}
 {
     //comments
 }",
@@ -1853,7 +1860,7 @@ public async Task TestBracePlacement()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
-class C : [|IServiceProvider|]",
+class C : {|CS0535:IServiceProvider|}{|CS1513:|}{|CS1514:|}",
 @"using System;
 class C : IServiceProvider
 {
@@ -1869,19 +1876,21 @@ public object GetService(Type serviceType)
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestMissingWithIncompleteMember()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"interface ITest
 {
     void Method();
 }
 
-class Test : [|ITest|]
+class Test : ITest
 {
-    p public void Method()
+    p {|CS1585:public|} void Method()
     {
-        throw new NotImplementedException();
+        throw new System.NotImplementedException();
     }
-}");
+}";
+
+            await VerifyCS.VerifyCodeFixAsync(code, code);
         }
 
         [WorkItem(541380, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541380")]
@@ -1894,7 +1903,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int p { get; set; }
 }
 
-class c1 : [|i1|]
+class c1 : {|CS0535:i1|}
 {
 }",
 @"interface i1
@@ -1917,35 +1926,28 @@ int i1.p
         }
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::i1;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(541981, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541981")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestNoDelegateThroughField1()
         {
-            await TestActionCountAsync(
+            var code =
 @"interface I
 {
     void Method1();
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
     I i { get; set; }
-}",
-count: 3);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
-{
-    void Method1();
-}
+}";
 
-class C : [|I|]
-{
-    I i { get; set; }
-}",
-@"interface I
+            await new VerifyCS.Test
+            {
+                TestCode = code,
+                FixedCode = @"interface I
 {
     void Method1();
 }
@@ -1959,18 +1961,16 @@ public void Method1()
         throw new System.NotImplementedException();
     }
 }",
-index: 0);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
-{
-    void Method1();
-}
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(3, codeActions.Length),
+                CodeActionEquivalenceKey = "False;False;True:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            }.RunAsync();
 
-class C : [|I|]
-{
-    I i { get; set; }
-}",
-@"interface I
+            await new VerifyCS.Test
+            {
+                TestCode = code,
+                FixedCode = @"interface I
 {
     void Method1();
 }
@@ -1984,18 +1984,16 @@ public void Method1()
         i.Method1();
     }
 }",
-index: 1);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
-{
-    void Method1();
-}
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(3, codeActions.Length),
+                CodeActionEquivalenceKey = "False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;i",
+                CodeActionIndex = 1,
+            }.RunAsync();
 
-class C : [|I|]
-{
-    I i { get; set; }
-}",
-@"interface I
+            await new VerifyCS.Test
+            {
+                TestCode = code,
+                FixedCode = @"interface I
 {
     void Method1();
 }
@@ -2009,7 +2007,11 @@ void I.Method1()
         throw new System.NotImplementedException();
     }
 }",
-index: 2);
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(3, codeActions.Length),
+                CodeActionEquivalenceKey = "True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 2,
+            }.RunAsync();
         }
 
         [WorkItem(768799, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/768799")]
@@ -2019,7 +2021,7 @@ public async Task TestImplementIReadOnlyListThroughField()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System.Collections.Generic;
 
-class A : [|IReadOnlyList<int>|]
+class A : {|CS0535:{|CS0535:{|CS0535:{|CS0535:IReadOnlyList<int>|}|}|}|}
 {
     int[] field;
 }",
@@ -2056,7 +2058,7 @@ IEnumerator IEnumerable.GetEnumerator()
         return field.GetEnumerator();
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::System.Collections.Generic.IReadOnlyList<int>;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;field", 1));
         }
 
         [WorkItem(768799, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/768799")]
@@ -2066,7 +2068,7 @@ public async Task TestImplementIReadOnlyListThroughProperty()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System.Collections.Generic;
 
-class A : [|IReadOnlyList<int>|]
+class A : {|CS0535:{|CS0535:{|CS0535:{|CS0535:IReadOnlyList<int>|}|}|}|}
 {
     int[] field { get; set; }
 }",
@@ -2103,7 +2105,7 @@ IEnumerator IEnumerable.GetEnumerator()
         return field.GetEnumerator();
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::System.Collections.Generic.IReadOnlyList<int>;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;field", 1));
         }
 
         [WorkItem(768799, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/768799")]
@@ -2124,7 +2126,7 @@ int I.M()
     }
 }
 
-class B : [|I|]
+class B : {|CS0535:I|}
 {
     A a;
 }",
@@ -2150,51 +2152,25 @@ public int M()
         return ((I)a).M();
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;a", 1));
         }
 
         [WorkItem(768799, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/768799")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementInterfaceThroughField_FieldImplementsMultipleInterfaces()
         {
-            await TestActionCountAsync(
-@"interface I
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     int M();
 }
 
 interface I2
 {
-    int M2() }
-
-class A : I, I2
-{
-    int I.M()
-    {
-        return 0;
-    }
-
-    int I2.M2()
-    {
-        return 0;
-    }
-}
-
-class B : [|I|], I2
-{
-    A a;
-}",
-count: 3);
-            await TestActionCountAsync(
-@"interface I
-{
-    int M();
+    int M2();
 }
 
-interface I2
-{
-    int M2() }
-
 class A : I, I2
 {
     int I.M()
@@ -2208,47 +2184,24 @@ int I2.M2()
     }
 }
 
-class B : I, [|I2|]
+class B : {|CS0535:I|}, {|CS0535:I2|}
 {
     A a;
 }",
-count: 3);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface I
 {
     int M();
 }
 
 interface I2
 {
-    int M2() }
-
-class A : I, I2
-{
-    int I.M()
-    {
-        return 0;
-    }
-
-    int I2.M2()
-    {
-        return 0;
-    }
-}
-
-class B : [|I|], I2
-{
-    A a;
-}",
-@"interface I
-{
-    int M();
+    int M2();
 }
 
-interface I2
-{
-    int M2() }
-
 class A : I, I2
 {
     int I.M()
@@ -2262,7 +2215,7 @@ int I2.M2()
     }
 }
 
-class B : I, I2
+class B : I, {|CS0535:I2|}
 {
     A a;
 
@@ -2271,16 +2224,28 @@ public int M()
         return ((I)a).M();
     }
 }",
-index: 1);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(3, codeActions.Length),
+                DiagnosticSelector = diagnostics => diagnostics[0],
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne,
+                CodeActionEquivalenceKey = "False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;a",
+                CodeActionIndex = 1,
+            }.RunAsync();
+
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     int M();
 }
 
 interface I2
 {
-    int M2() }
+    int M2();
+}
 
 class A : I, I2
 {
@@ -2295,18 +2260,23 @@ int I2.M2()
     }
 }
 
-class B : I, [|I2|]
+class B : {|CS0535:I|}, {|CS0535:I2|}
 {
     A a;
 }",
-@"interface I
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface I
 {
     int M();
 }
 
 interface I2
 {
-    int M2() }
+    int M2();
+}
 
 class A : I, I2
 {
@@ -2321,7 +2291,7 @@ int I2.M2()
     }
 }
 
-class B : I, I2
+class B : {|CS0535:I|}, I2
 {
     A a;
 
@@ -2330,35 +2300,25 @@ public int M2()
         return ((I2)a).M2();
     }
 }",
-index: 1);
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(3, codeActions.Length),
+                DiagnosticSelector = diagnostics => diagnostics[1],
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne,
+                CodeActionEquivalenceKey = "False;False;False:global::I2;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;a",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [WorkItem(768799, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/768799")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementInterfaceThroughField_MultipleFieldsCanImplementInterface()
         {
-            await TestActionCountAsync(
-@"interface I
-{
-    int M();
-}
-
-class A : I
-{
-    int I.M()
-    {
-        return 0;
-    }
-}
-
-class B : [|I|]
-{
-    A a;
-    A aa;
-}",
-count: 4);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     int M();
 }
@@ -2371,12 +2331,16 @@ int I.M()
     }
 }
 
-class B : [|I|]
+class B : {|CS0535:I|}
 {
     A a;
     A aa;
 }",
-@"interface I
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface I
 {
     int M();
 }
@@ -2399,9 +2363,18 @@ public int M()
         return ((I)a).M();
     }
 }",
-index: 1);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(4, codeActions.Length),
+                CodeActionEquivalenceKey = "False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;a",
+                CodeActionIndex = 1,
+            }.RunAsync();
+
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     int M();
 }
@@ -2414,12 +2387,16 @@ int I.M()
     }
 }
 
-class B : [|I|]
+class B : {|CS0535:I|}
 {
     A a;
     A aa;
 }",
-@"interface I
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface I
 {
     int M();
 }
@@ -2442,22 +2419,31 @@ public int M()
         return ((I)aa).M();
     }
 }",
-index: 2);
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(4, codeActions.Length),
+                CodeActionEquivalenceKey = "False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;aa",
+                CodeActionIndex = 2,
+            }.RunAsync();
         }
 
         [WorkItem(768799, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/768799")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementInterfaceThroughField_MultipleFieldsForMultipleInterfaces()
         {
-            await TestActionCountAsync(
-@"interface I
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     int M();
 }
 
 interface I2
 {
-    int M2() }
+    int M2();
+}
 
 class A : I
 {
@@ -2475,21 +2461,24 @@ int I2.M2()
     }
 }
 
-class C : [|I|], I2
+class C : {|CS0535:I|}, {|CS0535:I2|}
 {
     A a;
     B b;
 }",
-count: 3);
-            await TestActionCountAsync(
-@"interface I
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface I
 {
     int M();
 }
 
 interface I2
 {
-    int M2() }
+    int M2();
+}
 
 class A : I
 {
@@ -2507,21 +2496,38 @@ int I2.M2()
     }
 }
 
-class C : I, [|I2|]
+class C : I, {|CS0535:I2|}
 {
     A a;
     B b;
+
+    public int M()
+    {
+        return ((I)a).M();
+    }
 }",
-count: 3);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(3, codeActions.Length),
+                DiagnosticSelector = diagnostics => diagnostics[0],
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne,
+                CodeActionEquivalenceKey = "False;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;a",
+                CodeActionIndex = 1,
+            }.RunAsync();
+
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     int M();
 }
 
 interface I2
 {
-    int M2() }
+    int M2();
+}
 
 class A : I
 {
@@ -2539,19 +2545,24 @@ int I2.M2()
     }
 }
 
-class C : [|I|], I2
+class C : {|CS0535:I|}, {|CS0535:I2|}
 {
     A a;
     B b;
 }",
-@"interface I
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface I
 {
     int M();
 }
 
 interface I2
 {
-    int M2() }
+    int M2();
+}
 
 class A : I
 {
@@ -2569,57 +2580,81 @@ int I2.M2()
     }
 }
 
-class C : I, I2
+class C : {|CS0535:I|}, I2
 {
     A a;
     B b;
 
-    public int M()
+    public int M2()
     {
-        return ((I)a).M();
+        return ((I2)b).M2();
     }
 }",
-index: 1);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(3, codeActions.Length),
+                DiagnosticSelector = diagnostics => diagnostics[1],
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne,
+                CodeActionEquivalenceKey = "False;False;False:global::I2;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;b",
+                CodeActionIndex = 1,
+            }.RunAsync();
+        }
+
+        [WorkItem(18556, "https://github.com/dotnet/roslyn/issues/18556")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestImplementInterfaceThroughExplicitProperty()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface IA
+{
+    IB B { get; }
+}
+interface IB
 {
     int M();
 }
-
-interface I2
+class AB : IA, {|CS0535:IB|}
 {
-    int M2() }
-
-class A : I
+    IB IA.B => null;
+}",
+                FixedCode = @"interface IA
 {
-    int I.M()
-    {
-        return 0;
-    }
+    IB B { get; }
 }
-
-class B : I2
+interface IB
 {
-    int I2.M2()
-    {
-        return 0;
-    }
+    int M();
 }
-
-class C : I, [|I2|]
+class AB : IA, IB
 {
-    A a;
-    B b;
+    IB IA.B => null;
+
+    public int M()
+    {
+        return ((IA)this).B.M();
+    }
 }",
-@"interface I
+                Options = { AllOptionsOff },
+                CodeActionsVerifier = codeActions => Assert.Equal(3, codeActions.Length),
+                CodeActionEquivalenceKey = "False;False;False:global::IB;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;IA.B",
+                CodeActionIndex = 1,
+            }.RunAsync();
+        }
+
+        [WorkItem(768799, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/768799")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestNoImplementThroughIndexer()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     int M();
 }
 
-interface I2
-{
-    int M2() }
-
 class A : I
 {
     int I.M()
@@ -2628,83 +2663,55 @@ int I.M()
     }
 }
 
-class B : I2
-{
-    int I2.M2()
-    {
-        return 0;
-    }
-}
-
-class C : I, I2
+class B : {|CS0535:I|}
 {
-    A a;
-    B b;
-
-    public int M2()
+    A this[int index]
     {
-        return ((I2)b).M2();
-    }
-}",
-index: 1);
-        }
-
-        [WorkItem(18556, "https://github.com/dotnet/roslyn/issues/18556")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
-        public async Task TestImplementInterfaceThroughExplicitProperty()
+        get
         {
-            await TestActionCountAsync(
-@"interface IA
-{
-    IB B { get; }
-}
-interface IB
-{
-    int M();
-}
-class AB : IA, [|IB|]
-{
-    IB IA.B => null;
+            return null;
+        }
+    }
 }",
-count: 3);
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IA
-{
-    IB B { get; }
-}
-interface IB
+                FixedCode = @"interface I
 {
     int M();
 }
-class AB : IA, [|IB|]
-{
-    IB IA.B => null;
-}",
-@"interface IA
-{
-    IB B { get; }
-}
-interface IB
+
+class A : I
 {
-    int M();
+    int I.M()
+    {
+        return 0;
+    }
 }
-class AB : IA, [|IB|]
+
+class B : I
 {
-    IB IA.B => null;
+    A this[int index]
+    {
+        get
+        {
+            return null;
+        }
+    }
 
     public int M()
     {
-        return ((IA)this).B.M();
+        throw new System.NotImplementedException();
     }
-}", index: 1);
+}",
+                CodeActionsVerifier = codeActions => Assert.Equal(2, codeActions.Length),
+            }.RunAsync();
         }
 
         [WorkItem(768799, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/768799")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
-        public async Task TestNoImplementThroughIndexer()
+        public async Task TestNoImplementThroughWriteOnlyProperty()
         {
-            await TestActionCountAsync(
-@"interface I
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     int M();
 }
@@ -2717,25 +2724,16 @@ int I.M()
     }
 }
 
-class B : [|I|]
+class B : {|CS0535:I|}
 {
-    A this[int index]
+    A a
     {
-        get
+        set
         {
-            return null;
         }
-    };
+    }
 }",
-count: 2);
-        }
-
-        [WorkItem(768799, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/768799")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
-        public async Task TestNoImplementThroughWriteOnlyProperty()
-        {
-            await TestActionCountAsync(
-@"interface I
+                FixedCode = @"interface I
 {
     int M();
 }
@@ -2748,7 +2746,7 @@ int I.M()
     }
 }
 
-class B : [|I|]
+class B : {|CS0535:I|}
 {
     A a
     {
@@ -2756,8 +2754,14 @@ A a
         {
         }
     }
+
+    public int M()
+    {
+        throw new System.NotImplementedException();
+    }
 }",
-count: 2);
+                CodeActionsVerifier = codeActions => Assert.Equal(2, codeActions.Length),
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -2771,10 +2775,10 @@ interface IGoo
 
 class CanGoo : IGoo
 {
-    public event EventHandler E;
+    public event System.EventHandler E;
 }
 
-class HasCanGoo : [|IGoo|]
+class HasCanGoo : {|CS0535:IGoo|}
 {
     CanGoo canGoo;
 }",
@@ -2788,7 +2792,7 @@ interface IGoo
 
 class CanGoo : IGoo
 {
-    public event EventHandler E;
+    public event System.EventHandler E;
 }
 
 class HasCanGoo : IGoo
@@ -2807,17 +2811,17 @@ public event EventHandler E
             ((IGoo)canGoo).E -= value;
         }
     }
-}", index: 1);
+}", codeAction: ("False;False;False:global::IGoo;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;canGoo", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementEventThroughExplicitMember()
         {
             await TestInRegularAndScriptAsync(
-@"interface IGoo { event System . EventHandler E ; } class CanGoo : IGoo { event IGoo.EventHandler E; } class HasCanGoo : [|IGoo|] { CanGoo canGoo; } ",
+@"interface IGoo { event System . EventHandler E ; } class CanGoo : IGoo { event System.EventHandler IGoo.E { add { } remove { } } } class HasCanGoo : {|CS0535:IGoo|} { CanGoo canGoo; } ",
 @"using System;
 
-interface IGoo { event System . EventHandler E ; } class CanGoo : IGoo { event IGoo.EventHandler E; } class HasCanGoo : IGoo { CanGoo canGoo;
+interface IGoo { event System . EventHandler E ; } class CanGoo : IGoo { event System.EventHandler IGoo.E { add { } remove { } } } class HasCanGoo : IGoo { CanGoo canGoo;
 
     public event EventHandler E
     {
@@ -2832,7 +2836,7 @@ public event EventHandler E
         }
     }
 } ",
-index: 1);
+codeAction: ("False;False;False:global::IGoo;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;canGoo", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -2844,7 +2848,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     event System.EventHandler E;
 }
 
-abstract class Goo : [|IGoo|]
+abstract class Goo : {|CS0535:IGoo|}
 {
 }",
 @"using System;
@@ -2858,7 +2862,7 @@ abstract class Goo : IGoo
 {
     public event EventHandler E;
 }",
-index: 0);
+codeAction: ("False;False;True:global::IGoo;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 0));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -2870,7 +2874,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     event System.EventHandler E;
 }
 
-abstract class Goo : [|IGoo|]
+abstract class Goo : {|CS0535:IGoo|}
 {
 }",
 @"using System;
@@ -2884,7 +2888,7 @@ abstract class Goo : IGoo
 {
     public abstract event EventHandler E;
 }",
-index: 1);
+codeAction: ("False;True;True:global::IGoo;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -2896,7 +2900,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     event System.EventHandler E;
 }
 
-abstract class Goo : [|IGoo|]
+abstract class Goo : {|CS0535:IGoo|}
 {
 }",
 @"using System;
@@ -2921,44 +2925,49 @@ event EventHandler IGoo.E
         }
     }
 }",
-index: 2);
+codeAction: ("True;False;False:global::IGoo;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 2));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestFaultToleranceInStaticMembers_01()
         {
-            await TestMissingAsync(
-@"interface IFoo
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IFoo
 {
     static string Name { set; get; }
 
-    static int Foo(string s);
+    static int {|CS0501:Foo|}(string s);
 }
 
-class Program : [|IFoo|]
+class Program : IFoo
 {
-}");
+}",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestFaultToleranceInStaticMembers_02()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IFoo
+            var test = new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IFoo
 {
     string Name { set; get; }
 
-    static int Foo(string s);
+    static int {|CS0501:Foo|}(string s);
 }
 
-class Program : [|IFoo|]
+class Program : {|CS0535:IFoo|}
 {
 }",
-@"interface IFoo
+                FixedCode = @"interface IFoo
 {
     string Name { set; get; }
 
-    static int Foo(string s);
+    static int {|CS0501:Foo|}(string s);
 }
 
 class Program : IFoo
@@ -2975,24 +2984,30 @@ public string Name
             throw new System.NotImplementedException();
         }
     }
-}");
+}",
+            };
+
+            test.Options.AddRange(AllOptionsOff);
+            await test.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestFaultToleranceInStaticMembers_03()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IGoo
+            var test = new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IGoo
 {
     static string Name { set; get; }
 
     int Goo(string s);
 }
 
-class Program : [|IGoo|]
+class Program : {|CS0535:IGoo|}
 {
 }",
-@"interface IGoo
+                FixedCode = @"interface IGoo
 {
     static string Name { set; get; }
 
@@ -3005,7 +3020,11 @@ public int Goo(string s)
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+            };
+
+            test.Options.AddRange(AllOptionsOff);
+            await test.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -3017,7 +3036,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int this[int index] { get; set; }
 }
 
-class IndexerClass : [|ISomeInterface|]
+class IndexerClass : {|CS0535:ISomeInterface|}
 {
 }",
 @"public interface ISomeInterface
@@ -3051,7 +3070,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int this[int index] { get; set; }
 }
 
-class IndexerClass : [|ISomeInterface|]
+class IndexerClass : {|CS0535:ISomeInterface|}
 {
 }",
 @"public interface ISomeInterface
@@ -3074,7 +3093,7 @@ int ISomeInterface.this[int index]
         }
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::ISomeInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -3086,7 +3105,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int this[int index] { get; }
 }
 
-class IndexerClass : [|ISomeInterface|]
+class IndexerClass : {|CS0535:ISomeInterface|}
 {
 }",
 @"public interface ISomeInterface
@@ -3116,7 +3135,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo<T>() where T : class;
 }
 
-class A : [|I|]
+class A : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -3143,7 +3162,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo<T>() where T : class;
 }
 
-class A : [|I|]
+class A : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -3158,7 +3177,7 @@ void I.Goo<T>()
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(542357, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542357")]
@@ -3171,7 +3190,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo<T>() where T : System.Attribute;
 }
 
-class A : [|I|]
+class A : {|CS0535:I|}
 {
 }",
 @"using System;
@@ -3200,7 +3219,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int this[int x] { get; set; }
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -3237,7 +3256,7 @@ interface I
     void Goo<T>() where T : IComparable<T>;
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System;
@@ -3268,7 +3287,7 @@ interface I
     void Goo<T>() where T : IComparable<T>;
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System;
@@ -3285,7 +3304,7 @@ void I.Goo<T>()
         throw new NotImplementedException();
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(542587, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542587")]
@@ -3298,7 +3317,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo<T>() where T : class, S;
 }
 
-class A : [|I<string>|]
+class A : {|CS0535:I<string>|}
 {
 }",
 @"interface I<S>
@@ -3325,7 +3344,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo<T>() where T : class, S;
 }
 
-class A : [|I<object>|]
+class A : {|CS0535:I<object>|}
 {
 }",
 @"interface I<S>
@@ -3352,7 +3371,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo<T>() where T : class, S;
 }
 
-class A : [|I<object>|]
+class A : {|CS0535:I<object>|}
 {
 }",
 @"interface I<S>
@@ -3367,7 +3386,7 @@ void I<object>.Goo<T>()
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::I<object>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(542587, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542587")]
@@ -3382,7 +3401,7 @@ interface I<S>
     void Goo<T>() where T : class, S;
 }
 
-class A : [|I<Delegate>|]
+class A : {|CS0535:I<Delegate>|}
 {
 }",
 @"using System;
@@ -3413,7 +3432,7 @@ interface I<S>
     void Goo<T>() where T : class, S;
 }
 
-class A : [|I<MulticastDelegate>|]
+class A : {|CS0535:I<MulticastDelegate>|}
 {
 }",
 @"using System;
@@ -3446,7 +3465,7 @@ interface I<S>
 
 delegate void Bar();
 
-class A : [|I<Bar>|]
+class A : {|CS0535:I<Bar>|}
 {
 }",
 @"using System;
@@ -3479,7 +3498,7 @@ interface I<S>
     void Goo<T>() where T : class, S;
 }
 
-class A : [|I<Enum>|]
+class A : {|CS0535:I<Enum>|}
 {
 }",
 @"using System;
@@ -3510,7 +3529,7 @@ interface I<S>
     void Goo<T>() where T : class, S;
 }
 
-class A : [|I<int[]>|]
+class A : {|CS0535:I<int[]>|}
 {
 }",
 @"using System;
@@ -3545,7 +3564,7 @@ enum E
 {
 }
 
-class A : [|I<E>|]
+class A : {|CS0535:I<E>|}
 {
 }",
 @"using System;
@@ -3561,7 +3580,7 @@ enum E
 
 class A : I<E>
 {
-    void I<E>.Goo<T>()
+    void I<E>.Goo<{|CS0455:T|}>()
     {
         throw new NotImplementedException();
     }
@@ -3580,7 +3599,7 @@ interface I<S>
     void Goo<T>() where T : S;
 }
 
-class A : [|I<ValueType>|]
+class A : {|CS0535:I<ValueType>|}
 {
 }",
 @"using System;
@@ -3611,7 +3630,7 @@ interface I<S>
     void Goo<T>() where T : S;
 }
 
-class C : [|I<Array>|]
+class C : {|CS0535:I<Array>|}
 {
 }",
 @"using System;
@@ -3642,7 +3661,7 @@ interface I<S>
     void Goo<T>() where T : Exception, S;
 }
 
-class C : [|I<Attribute>|]
+class C : {|CS0535:I<Attribute>|}
 {
 }",
 @"using System;
@@ -3654,7 +3673,7 @@ interface I<S>
 
 class C : I<Attribute>
 {
-    void I<Attribute>.Goo<T>()
+    void I<Attribute>.Goo<{|CS0455:T|}>()
     {
         throw new NotImplementedException();
     }
@@ -3673,7 +3692,7 @@ interface I<S>
     void Goo<T>() where T : class, S;
 }
 
-class C : [|I<Exception>|]
+class C : {|CS0535:I<Exception>|}
 {
 }",
 @"using System;
@@ -3705,7 +3724,7 @@ interface I<T>
     void Goo<S>(T x, IList<S> list) where S : T;
 }
 
-class A<S> : [|I<S>|]
+class A<S> : {|CS0535:I<S>|}
 {
 }",
 @"using System;
@@ -3738,7 +3757,7 @@ interface I<T>
     void Goo<S>(T x, IList<S> list) where S : T;
 }
 
-class A<S> : [|I<S>|]
+class A<S> : {|CS0535:I<S>|}
 {
 }",
 @"using System;
@@ -3756,7 +3775,7 @@ void I<S>.Goo<S1>(S x, IList<S1> list)
         throw new NotImplementedException();
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::I<S>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(542505, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542505")]
@@ -3774,7 +3793,7 @@ void Goo<A, B>(X x, Y y, IList<A> list1, IList<B> list2)
         where B : IList<A>;
 }
 
-class C<A, B> : [|I<A, B>|]
+class C<A, B> : {|CS0535:I<A, B>|}
 {
 }",
 @"using System;
@@ -3813,7 +3832,7 @@ void Goo<A, B>(X x, Y y, IList<A> list1, IList<B> list2)
         where B : IList<A>;
 }
 
-class C<A, B> : [|I<A, B>|]
+class C<A, B> : {|CS0535:I<A, B>|}
 {
 }",
 @"using System;
@@ -3833,7 +3852,7 @@ void I<A, B>.Goo<A1, B1>(A x, B y, IList<A1> list1, IList<B1> list2)
         throw new NotImplementedException();
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::I<A, B>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(542506, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542506")]
@@ -3854,7 +3873,7 @@ interface I
         void Goo(B x);
     }
 
-    class C<U> : [|I|]
+    class C<U> : {|CS0535:I|}
     {
     }
 }",
@@ -3897,7 +3916,7 @@ interface I
         void Goo(B[] x);
     }
 
-    class C<U> : [|I|]
+    class C<U> : {|CS0535:I|}
     {
     }
 }",
@@ -3938,7 +3957,7 @@ interface I
         void Goo(B[][,][,,][,,,] x);
     }
 
-    class C<U> : [|I|]
+    class C<U> : {|CS0535:I|}
     {
     }
 }",
@@ -3973,7 +3992,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int Gibberish { get; set; }
 }
 
-abstract class Goo : [|IGoo|]
+abstract class Goo : {|CS0535:IGoo|}
 {
 }",
 @"interface IGoo
@@ -3985,22 +4004,24 @@ abstract class Goo : IGoo
 {
     public abstract int Gibberish { get; set; }
 }",
-index: 1);
+codeAction: ("False;True;True:global::IGoo;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(544210, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544210")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestMissingOnWrongArity()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"interface I1<T>
 {
     int X { get; set; }
 }
 
-class C : [|I1|]
+class C : {|CS0305:I1|}
 {
-}");
+}";
+
+            await VerifyCS.VerifyCodeFixAsync(code, code);
         }
 
         [WorkItem(544281, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544281")]
@@ -4013,7 +4034,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int Goo(int g = 0);
 }
 
-class Opt : [|IOptional|]
+class Opt : {|CS0535:IOptional|}
 {
 }",
 @"interface IOptional
@@ -4040,7 +4061,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int Goo(int g = 0);
 }
 
-class Opt : [|IOptional|]
+class Opt : {|CS0535:IOptional|}
 {
 }",
 @"interface IOptional
@@ -4055,20 +4076,22 @@ int IOptional.Goo(int g)
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::IOptional;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestMissingInHiddenType()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"using System;
 
-class Program : [|IComparable|]
+class Program : {|CS0535:IComparable|}
 {
 #line hidden
 }
-#line default");
+#line default";
+
+            await VerifyCS.VerifyCodeFixAsync(code, code);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -4078,7 +4101,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
 @"#line default
 using System;
 
-partial class Program : [|IComparable|]
+partial class Program : {|CS0535:IComparable|}
 {
     void Goo()
     {
@@ -4110,7 +4133,7 @@ public async Task TestGenerateIfAvailableRegionExists()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-partial class Program : [|IComparable|]
+partial class Program : {|CS0535:IComparable|}
 {
 #line hidden
 }
@@ -4140,23 +4163,26 @@ public int CompareTo(object obj)
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestNoGenerateInVenusCase1()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"using System;
 #line 1 ""Bar""
-class Goo : [|IComparable|]
+class Goo : {|CS0535:IComparable|}{|CS1513:|}{|CS1514:|}
 
 
 #line default
 #line hidden
-// stuff");
+// stuff";
+
+            await VerifyCS.VerifyCodeFixAsync(code, code);
         }
 
         [WorkItem(545476, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545476")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestOptionalDateTime1()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"using System;
+            await new VerifyCS.Test
+            {
+                TestCode = @"using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -4165,10 +4191,10 @@ interface IGoo
     void Goo([Optional][DateTimeConstant(100)] DateTime x);
 }
 
-public class C : [|IGoo|]
+public class C : {|CS0535:IGoo|}
 {
 }",
-@"using System;
+                FixedCode = @"using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -4183,7 +4209,12 @@ public void Goo([DateTimeConstant(100), Optional] DateTime x)
     {
         throw new NotImplementedException();
     }
-}");
+}",
+                Options = { AllOptionsOff },
+
+                // 🐛 one value is generated with 0L instead of 0
+                CodeActionValidationMode = CodeActionValidationMode.None,
+            }.RunAsync();
         }
 
         [WorkItem(545476, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545476")]
@@ -4200,7 +4231,7 @@ interface IGoo
     void Goo([Optional][DateTimeConstant(100)] DateTime x);
 }
 
-public class C : [|IGoo|]
+public class C : {|CS0535:IGoo|}
 {
 }",
 @"using System;
@@ -4219,7 +4250,7 @@ void IGoo.Goo(DateTime x)
         throw new NotImplementedException();
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::IGoo;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(545477, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545477")]
@@ -4236,7 +4267,7 @@ interface IGoo
     void Goo2([Optional][IDispatchConstant] object x);
 }
 
-public class C : [|IGoo|]
+public class C : {|CS0535:{|CS0535:IGoo|}|}
 {
 }",
 @"using System.Runtime.CompilerServices;
@@ -4276,7 +4307,7 @@ interface IGoo
     void Goo2([Optional][IDispatchConstant] object x);
 }
 
-public class C : [|IGoo|]
+public class C : {|CS0535:{|CS0535:IGoo|}|}
 {
 }",
 @"using System.Runtime.CompilerServices;
@@ -4300,7 +4331,7 @@ void IGoo.Goo2(object x)
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::IGoo;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(545464, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545464")]
@@ -4313,7 +4344,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo();
 }
 
-public class Goo : [|IGoo|]
+public class Goo : {|CS0535:IGoo|}
 {
 }",
 @"interface IGoo
@@ -4334,7 +4365,7 @@ void IGoo.Goo()
         public async Task TestStringLiteral()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IGoo { void Goo ( string s = ""\"""" ) ; } class B : [|IGoo|] { } ",
+@"interface IGoo { void Goo ( string s = ""\"""" ) ; } class B : {|CS0535:IGoo|} { } ",
 @"interface IGoo { void Goo ( string s = ""\"""" ) ; }
 class B : IGoo
 {
@@ -4359,7 +4390,7 @@ interface d
     void m(b? x = null, b? y = default(b?));
 }
 
-class c : [|d|]
+class c : {|CS0535:d|}
 {
 }",
 @"struct b
@@ -4394,7 +4425,7 @@ interface d
     void m(b? x = null, b? y = default(b?));
 }
 
-class c : [|d|]
+class c : {|CS0535:d|}
 {
 }",
 @"struct b
@@ -4412,7 +4443,7 @@ void d.m(b? x, b? y)
     {
         throw new System.NotImplementedException();
     }
-}", 1);
+}", codeAction: ("True;False;False:global::d;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(916114, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/916114")]
@@ -4425,7 +4456,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void m(int? x = 5, int? y = null);
 }
 
-class c : [|d|]
+class c : {|CS0535:d|}
 {
 }",
 @"interface d
@@ -4454,7 +4485,7 @@ interface I
     void Goo([Optional] I o);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System.Runtime.InteropServices;
@@ -4476,8 +4507,9 @@ public void Goo([Optional] I o)
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestIntegralAndFloatLiterals()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface I
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface I
 {
     void M01(short s = short.MinValue);
     void M02(short s = -1);
@@ -4505,10 +4537,10 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void M24(double s = double.MaxValue);
 }
 
-class C : [|I|]
+class C : {|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:I|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}|}
 {
 }",
-@"interface I
+                FixedCode = @"interface I
 {
     void M01(short s = short.MinValue);
     void M02(short s = -1);
@@ -4657,7 +4689,12 @@ public void M24(double s = double.MaxValue)
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+                Options = { AllOptionsOff },
+
+                // 🐛 one value is generated with 0U instead of 0
+                CodeActionValidationMode = CodeActionValidationMode.None,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -4685,7 +4722,7 @@ interface I
     void M2(FlagE e = FlagE.A | FlagE.B);
 }
 
-class C : [|I|]
+class C : {|CS0535:{|CS0535:I|}|}
 {
 }",
 @"using System;
@@ -4744,7 +4781,7 @@ interface I
     void M11(char c = '\u2029');
 }
 
-class C : [|I|]
+class C : {|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:I|}|}|}|}|}|}|}|}|}|}|}
 {
 }",
 @"using System;
@@ -4835,7 +4872,7 @@ interface I
     void Goo(DayOfWeek x = DayOfWeek.Friday);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
     DayOfWeek DayOfWeek { get; set; }
 }",
@@ -4867,7 +4904,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo(decimal x = decimal.MaxValue);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -4894,7 +4931,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo(decimal? x = decimal.MaxValue);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -4923,7 +4960,7 @@ interface I
     void Goo(DayOfWeek? x = DayOfWeek.Friday);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System;
@@ -4952,7 +4989,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo(byte x = 1);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -4980,7 +5017,7 @@ interface I
     void Goo(ConsoleColor x = (ConsoleColor)(-1));
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }";
 
@@ -5014,7 +5051,7 @@ interface I
     void Goo(ConsoleColor x = (ConsoleColor)int.MaxValue);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System;
@@ -5048,7 +5085,7 @@ interface I
     void Goo(E x = 0);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"enum E
@@ -5082,7 +5119,7 @@ interface I
     void Goo([Optional][DefaultParameterValue(1)] int x, int[,] y);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System.Runtime.InteropServices;
@@ -5094,7 +5131,7 @@ interface I
 
 class C : I
 {
-    public void Goo([DefaultParameterValue(1), Optional] int x = 1, int[,] y = null)
+    public void Goo([{|CS1745:DefaultParameterValue|}(1), {|CS1745:Optional|}] int x = {|CS8017:1|}, int[,] y = null)
     {
         throw new System.NotImplementedException();
     }
@@ -5113,7 +5150,7 @@ interface I
     void Goo([Optional, DefaultParameterValue(1)] int x, int[] y, int[] z);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System.Runtime.InteropServices;
@@ -5125,7 +5162,7 @@ interface I
 
 class C : I
 {
-    public void Goo([DefaultParameterValue(1), Optional] int x = 1, int[] y = null, int[] z = null)
+    public void Goo([{|CS1745:DefaultParameterValue|}(1), {|CS1745:Optional|}] int x = {|CS8017:1|}, int[] y = null, int[] z = null)
     {
         throw new System.NotImplementedException();
     }
@@ -5136,7 +5173,9 @@ public void Goo([DefaultParameterValue(1), Optional] int x = 1, int[] y = null,
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestAttributeInParameter()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
+            var test = new VerifyCS.Test
+            {
+                TestCode =
 @"using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -5145,10 +5184,11 @@ interface I
 {
     void Goo([Optional][DateTimeConstant(100)] DateTime d1, [Optional][IUnknownConstant] object d2);
 }
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }
 ",
+                FixedCode =
 @"using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -5164,7 +5204,13 @@ public void Goo([DateTimeConstant(100), Optional] DateTime d1, [IUnknownConstant
         throw new NotImplementedException();
     }
 }
-");
+",
+                // 🐛 the DateTimeConstant attribute is generated with 100L instead of 100
+                CodeActionValidationMode = CodeActionValidationMode.None,
+            };
+
+            test.Options.AddRange(AllOptionsOff);
+            await test.RunAsync();
         }
 
         [WorkItem(545897, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545897")]
@@ -5177,7 +5223,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void T1<T>(S x, T y);
 }
 
-class C<T> : [|I<T>|]
+class C<T> : {|CS0535:I<T>|}
 {
 }",
 @"interface I<S>
@@ -5206,7 +5252,7 @@ interface I<S>
     void Goo<T>(S y, List<T>.Enumerator x);
 }
 
-class D<T> : [|I<T>|]
+class D<T> : {|CS0535:I<T>|}
 {
 }",
 @"using System.Collections.Generic;
@@ -5235,7 +5281,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo(float x = 1E10F);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -5262,7 +5308,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo<@class>();
 }
 
-class C : [|I|]",
+class C : {|CS0535:I|}{|CS1513:|}{|CS1514:|}",
 @"interface I
 {
     void Goo<@class>();
@@ -5289,7 +5335,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo2(decimal x = -1E28M);
 }
 
-class C : [|I|]
+class C : {|CS0535:{|CS0535:I|}|}
 {
 }",
 @"interface I
@@ -5322,7 +5368,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo(decimal x = 0.1M);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -5347,8 +5393,8 @@ await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
  
 // Implement interface
-class C : [|IServiceProvider|] /*
-",
+class C : {|CS0535:IServiceProvider|} {|CS1035:|}/*
+{|CS1513:|}{|CS1514:|}",
 @"using System;
 
 // Implement interface
@@ -5371,7 +5417,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
  
 // Implement interface
-class C : [|IServiceProvider|]
+class C : {|CS0535:IServiceProvider|}{|CS1513:|}{|CS1514:|}
 #pragma warning disable
 ",
 @"using System;
@@ -5395,7 +5441,7 @@ public async Task TestCommentAfterInterfaceList1()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
  
-class C : [|IServiceProvider|] // Implement interface
+class C : {|CS0535:IServiceProvider|}{|CS1513:|}{|CS1514:|} // Implement interface
 ",
 @"using System;
 
@@ -5416,7 +5462,7 @@ public async Task TestCommentAfterInterfaceList2()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
  
-class C : [|IServiceProvider|] 
+class C : {|CS0535:IServiceProvider|}{|CS1513:|}{|CS1514:|} 
 // Implement interface
 ",
 @"using System;
@@ -5439,7 +5485,7 @@ public async Task TestImplementIDisposable_NoDisposePattern()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
-class C : [|IDisposable|]",
+class C : {|CS0535:IDisposable|}{|CS1513:|}{|CS1514:|}",
 @"using System;
 class C : IDisposable
 {
@@ -5448,7 +5494,7 @@ public void Dispose()
         throw new NotImplementedException();
     }
 }
-", index: 0);
+", codeAction: ("False;False;True:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 0));
         }
 
         [WorkItem(994456, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/994456")]
@@ -5458,7 +5504,7 @@ public async Task TestImplementIDisposable_DisposePattern()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
-class C : [|IDisposable|]",
+class C : {|CS0535:IDisposable|}{|CS1513:|}{|CS1514:|}",
 $@"using System;
 class C : IDisposable
 {{
@@ -5466,7 +5512,7 @@ class C : IDisposable
 
 {DisposePattern("protected virtual ", "C", "public void ")}
 }}
-", index: 1);
+", codeAction: ("False;False;True:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 1));
         }
 
         [WorkItem(994456, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/994456")]
@@ -5476,7 +5522,7 @@ public async Task TestImplementIDisposableExplicitly_NoDisposePattern()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
-class C : [|IDisposable|]",
+class C : {|CS0535:IDisposable|}{|CS1513:|}{|CS1514:|}",
 @"using System;
 class C : IDisposable
 {
@@ -5485,7 +5531,7 @@ void IDisposable.Dispose()
         throw new NotImplementedException();
     }
 }
-", index: 2);
+", codeAction: ("True;False;False:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 2));
         }
 
         [WorkItem(994456, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/994456")]
@@ -5495,7 +5541,7 @@ public async Task TestImplementIDisposableExplicitly_DisposePattern()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
-class C : [|System.IDisposable|]
+class C : {|CS0535:System.IDisposable|}
 {
     class IDisposable
     {
@@ -5511,7 +5557,7 @@ class IDisposable
     }}
 
 {DisposePattern("protected virtual ", "C", "void System.IDisposable.")}
-}}", index: 3);
+}}", codeAction: ("True;False;False:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 3));
         }
 
         [WorkItem(994456, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/994456")]
@@ -5521,13 +5567,13 @@ public async Task TestImplementIDisposableAbstractly_NoDisposePattern()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
-abstract class C : [|IDisposable|]",
+abstract class C : {|CS0535:IDisposable|}{|CS1513:|}{|CS1514:|}",
 @"using System;
 abstract class C : IDisposable
 {
     public abstract void Dispose();
 }
-", index: 2);
+", codeAction: ("False;True;True:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 2));
         }
 
         [WorkItem(994456, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/994456")]
@@ -5537,7 +5583,7 @@ public async Task TestImplementIDisposableThroughMember_NoDisposePattern()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
-class C : [|IDisposable|]
+class C : {|CS0535:IDisposable|}
 {
     private IDisposable goo;
 }",
@@ -5550,22 +5596,29 @@ public void Dispose()
     {
         goo.Dispose();
     }
-}", index: 2);
+}", codeAction: ("False;False;False:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;goo", 2));
         }
 
         [WorkItem(941469, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/941469")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementIDisposableExplicitly_NoNamespaceImportForSystem()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"class C : [|System.IDisposable|]",
-$@"class C : System.IDisposable
+            await new VerifyCS.Test
+            {
+                TestCode = @"class C : {|CS0535:System.IDisposable|}{|CS1513:|}{|CS1514:|}",
+                FixedCode = $@"class C : System.IDisposable
 {{
     private bool disposedValue;
 
 {DisposePattern("protected virtual ", "C", "void System.IDisposable.", gcPrefix: "System.")}
 }}
-", index: 3);
+",
+                CodeActionEquivalenceKey = "True;False;False:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;",
+                CodeActionIndex = 3,
+
+                // 🐛 generated QualifiedName where SimpleMemberAccessExpression was expected
+                CodeActionValidationMode = CodeActionValidationMode.None,
+            }.RunAsync();
         }
 
         [WorkItem(951968, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/951968")]
@@ -5578,7 +5631,7 @@ interface I : IDisposable
 {
     void F();
 }
-class C : [|I|]
+class C : {|CS0535:{|CS0535:I|}|}
 {
 }",
 @"using System;
@@ -5597,7 +5650,7 @@ public void F()
     {
         throw new NotImplementedException();
     }
-}", index: 0);
+}", codeAction: ("False;False;True:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 0));
         }
 
         [WorkItem(951968, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/951968")]
@@ -5610,7 +5663,7 @@ interface I : IDisposable
 {
     void F();
 }
-class C : [|I|]
+class C : {|CS0535:{|CS0535:I|}|}
 {
 }",
 $@"using System;
@@ -5628,7 +5681,7 @@ public void F()
     }}
 
 {DisposePattern("protected virtual ", "C", "public void ")}
-}}", index: 1);
+}}", codeAction: ("False;False;True:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 1));
         }
 
         [WorkItem(951968, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/951968")]
@@ -5641,7 +5694,7 @@ interface I : IDisposable
 {
     void F();
 }
-class C : [|I|]
+class C : {|CS0535:{|CS0535:I|}|}
 {
 }",
 $@"using System;
@@ -5659,7 +5712,7 @@ void I.F()
     }}
 
 {DisposePattern("protected virtual ", "C", "void IDisposable.")}
-}}", index: 3);
+}}", codeAction: ("True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 3));
         }
 
         [WorkItem(941469, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/941469")]
@@ -5674,7 +5727,7 @@ interface IDisposable
         void Dispose();
     }
 
-    class C : [|IDisposable|]
+    class C : {|CS0535:IDisposable|}{|CS1513:|}{|CS1514:|}
 }",
 @"namespace System
 {
@@ -5690,7 +5743,7 @@ void IDisposable.Dispose()
             throw new NotImplementedException();
         }
     }
-}", index: 1);
+}", codeAction: ("True;False;False:global::System.IDisposable;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -5698,7 +5751,7 @@ public async Task TestDontImplementDisposePatternForStructures1()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
-struct S : [|IDisposable|]",
+struct S : {|CS0535:IDisposable|}{|CS1513:|}{|CS1514:|}",
 @"using System;
 struct S : IDisposable
 {
@@ -5715,7 +5768,7 @@ public async Task TestDontImplementDisposePatternForStructures2()
         {
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
-struct S : [|IDisposable|]",
+struct S : {|CS0535:IDisposable|}{|CS1513:|}{|CS1514:|}",
 @"using System;
 struct S : IDisposable
 {
@@ -5724,15 +5777,16 @@ void IDisposable.Dispose()
         throw new NotImplementedException();
     }
 }
-", index: 1);
+", codeAction: ("True;False;False:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(545924, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545924")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestEnumNestedInGeneric()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"class C<T>
+            var test = new VerifyCS.Test()
+            {
+                TestCode = @"class C<T>
 {
     public enum E
     {
@@ -5745,10 +5799,10 @@ interface I
     void Goo<T>(C<T>.E x = C<T>.E.X);
 }
 
-class D : [|I|]
+class D : {|CS0535:I|}
 {
 }",
-@"class C<T>
+                FixedCode = @"class C<T>
 {
     public enum E
     {
@@ -5767,7 +5821,13 @@ public void Goo<T>(C<T>.E x = C<T>.E.X)
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+                // 🐛 generated QualifiedName where SimpleMemberAccessExpression was expected
+                CodeActionValidationMode = CodeActionValidationMode.None,
+            };
+
+            test.Options.AddRange(AllOptionsOff);
+            await test.RunAsync();
         }
 
         [WorkItem(545939, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545939")]
@@ -5777,10 +5837,10 @@ public async Task TestUnterminatedString1()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-class C : [|IServiceProvider|] @""",
+class C : {|CS0535:IServiceProvider|} {|CS1039:|}@""{|CS1513:|}{|CS1514:|}",
 @"using System;
 
-class C : IServiceProvider @""""{
+class C : IServiceProvider {|CS1003:@""""|}{
     public object GetService(Type serviceType)
     {
         throw new NotImplementedException();
@@ -5796,10 +5856,10 @@ public async Task TestUnterminatedString2()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-class C : [|IServiceProvider|] """,
+class C : {|CS0535:IServiceProvider|} {|CS1010:|}""{|CS1513:|}{|CS1514:|}",
 @"using System;
 
-class C : IServiceProvider """"{
+class C : IServiceProvider {|CS1003:""""|}{
     public object GetService(Type serviceType)
     {
         throw new NotImplementedException();
@@ -5815,10 +5875,10 @@ public async Task TestUnterminatedString3()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-class C : [|IServiceProvider|] @""",
+class C : {|CS0535:IServiceProvider|} {|CS1039:|}@""{|CS1513:|}{|CS1514:|}",
 @"using System;
 
-class C : IServiceProvider @""""{
+class C : IServiceProvider {|CS1003:@""""|}{
     public object GetService(Type serviceType)
     {
         throw new NotImplementedException();
@@ -5834,10 +5894,10 @@ public async Task TestUnterminatedString4()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-class C : [|IServiceProvider|] """,
+class C : {|CS0535:IServiceProvider|} {|CS1010:|}""{|CS1513:|}{|CS1514:|}",
 @"using System;
 
-class C : IServiceProvider """"{
+class C : IServiceProvider {|CS1003:""""|}{
     public object GetService(Type serviceType)
     {
         throw new NotImplementedException();
@@ -5859,7 +5919,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo4(decimal x = -1E-24M);
 }
 
-class C : [|I|]
+class C : {|CS0535:{|CS0535:{|CS0535:{|CS0535:I|}|}|}|}
 {
 }",
 @"interface I
@@ -5898,8 +5958,9 @@ public void Goo4(decimal x = -0.000000000000000000000001M)
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestGenericEnumWithRenamedTypeParameters()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"class C<T>
+            var test = new VerifyCS.Test
+            {
+                TestCode = @"class C<T>
 {
     public enum E
     {
@@ -5912,10 +5973,10 @@ interface I<S>
     void Goo<T>(S y, C<T>.E x = C<T>.E.X);
 }
 
-class D<T> : [|I<T>|]
+class D<T> : {|CS0535:I<T>|}
 {
 }",
-@"class C<T>
+                FixedCode = @"class C<T>
 {
     public enum E
     {
@@ -5934,7 +5995,13 @@ public void Goo<T1>(T y, C<T1>.E x = C<T1>.E.X)
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+                // 🐛 generated QualifiedName where SimpleMemberAccessExpression was expected
+                CodeActionValidationMode = CodeActionValidationMode.None,
+            };
+
+            test.Options.AddRange(AllOptionsOff);
+            await test.RunAsync();
         }
 
         [WorkItem(545919, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545919")]
@@ -5947,7 +6014,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo<T>(S T1);
 }
 
-class C<T> : [|I<T>|]
+class C<T> : {|CS0535:I<T>|}
 {
 }",
 @"interface I<S>
@@ -5977,7 +6044,7 @@ interface I
     bool Goo([MarshalAs(UnmanagedType.U1)] bool x);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System.Runtime.InteropServices;
@@ -6011,7 +6078,7 @@ interface I
     bool Goo([MarshalAs(UnmanagedType.U1)] bool x);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System.Runtime.InteropServices;
@@ -6029,7 +6096,7 @@ bool I.Goo(bool x)
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+codeAction: ("True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(546443, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/546443")]
@@ -6044,7 +6111,7 @@ interface IGoo
     void Bar(DateTime DateTime);
 }
 
-class C : [|IGoo|]
+class C : {|CS0535:IGoo|}
 {
 }",
 @"using System;
@@ -6077,7 +6144,7 @@ interface I
     void Goo();
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System.Collections.Generic;
@@ -6112,7 +6179,7 @@ public interface I
     }
 }
 
-class C : [|N.I|]
+class C : {|CS0535:N.I|}
 {
 }",
 @"namespace N
@@ -6145,7 +6212,7 @@ public interface I
     }
 }
 
-class C : [|N.I|]
+class C : {|CS0535:N.I|}
 {
 }",
 @"using N;
@@ -6164,7 +6231,7 @@ void I.M()
     {
         throw new System.NotImplementedException();
     }
-}", index: 1);
+}", codeAction: ("True;False;False:global::N.I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(847464, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/847464")]
@@ -6181,7 +6248,7 @@ partial class C
 {
 }
 
-partial class C : [|I|]
+partial class C : {|CS0535:I|}
 {
 }",
 @"public interface I
@@ -6199,7 +6266,7 @@ void I.Goo()
     {
         throw new System.NotImplementedException();
     }
-}", index: 1);
+}", codeAction: ("True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(847464, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/847464")]
@@ -6212,7 +6279,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void Goo();
 }
 
-partial class C : [|I|]
+partial class C : {|CS0535:I|}
 {
 }
 
@@ -6234,15 +6301,16 @@ void I.Goo()
 
 partial class C
 {
-}", index: 1);
+}", codeAction: ("True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(847464, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/847464")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementInterfaceForPartialType3()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"public interface I
+            await new VerifyCS.Test
+            {
+                TestCode = @"public interface I
 {
     void Goo();
 }
@@ -6252,14 +6320,18 @@ public interface I2
     void Goo2();
 }
 
-partial class C : [|I|]
+partial class C : {|CS0535:I|}
 {
 }
 
-partial class C : I2
+partial class C : {|CS0535:I2|}
 {
 }",
-@"public interface I
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"public interface I
 {
     void Goo();
 }
@@ -6277,35 +6349,57 @@ void I.Goo()
     }
 }
 
-partial class C : I2
+partial class C : {|CS0535:I2|}
 {
-}", index: 1);
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne,
+                CodeActionEquivalenceKey = "True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [WorkItem(752447, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/752447")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestExplicitImplOfIndexedProperty()
         {
-            var initial = @"
-<Workspace>
-    <Project Language=""Visual Basic"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
+            var test = new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"
+public class Test : {|CS0535:{|CS0535:IGoo|}|}
+{
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1", LanguageNames.VisualBasic] =
+                        {
+                            Sources =
+                            {
+                                @"
 Public Interface IGoo
     Property IndexProp(ByVal p1 As Integer) As String
-End Interface
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-public class Test : [|IGoo|]
-{
-}
-        </Document>
-    </Project>
-</Workspace>";
-
-            var expected = @"
+End Interface",
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences =
+                    {
+                        "Assembly1",
+                    },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"
 public class Test : IGoo
 {
     string IGoo.get_IndexProp(int p1)
@@ -6317,39 +6411,52 @@ void IGoo.set_IndexProp(int p1, string Value)
     {
         throw new System.NotImplementedException();
     }
-}
-        ";
+}",
+                    },
+                },
+                CodeActionEquivalenceKey = "True;False;False:global::IGoo;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            };
 
-            await TestWithAllCodeStyleOptionsOffAsync(initial, expected, index: 1);
+            test.Options.AddRange(AllOptionsOff);
+            await test.RunAsync();
         }
 
         [WorkItem(602475, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/602475")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplicitImplOfIndexedProperty()
         {
-            var initial = @"
-<Workspace>
-    <Project Language=""Visual Basic"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-Public Interface I
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"using System;
+
+class C : {|CS0535:{|CS0535:I|}|}
+{
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1", LanguageNames.VisualBasic] =
+                        {
+                            Sources =
+                            {
+                                @"Public Interface I
     Property P(x As Integer)
-End Interface
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-using System;
-
-class C : [|I|]
-{
-}
-        </Document>
-    </Project>
-</Workspace>";
-
-            var expected = @"
-using System;
+End Interface",
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences = { "Assembly1" },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"using System;
 
 class C : I
 {
@@ -6362,40 +6469,56 @@ public void set_P(int x, object Value)
     {
         throw new NotImplementedException();
     }
-}
-        ";
-
-            await TestWithAllCodeStyleOptionsOffAsync(initial, expected, index: 0);
+}",
+                    },
+                },
+                CodeActionEquivalenceKey = "False;False;True:global::I;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementationOfIndexerWithInaccessibleAttributes()
         {
-            var initial = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
+            var test = new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"
+using System;
+
+class C : {|CS0535:I|}
+{
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"
 using System;
 internal class ShouldBeRemovedAttribute : Attribute { }
 public interface I
 {
     string this[[ShouldBeRemovedAttribute] int i] { get; set; }
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-using System;
-
-class C : [|I|]
-{
-}
-        </Document>
-    </Project>
-</Workspace>";
-
-            var expected = @"
+}"
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences =
+                    {
+                        "Assembly1",
+                    },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"
 using System;
 
 class C : I
@@ -6412,10 +6535,15 @@ public string this[int i]
             throw new NotImplementedException();
         }
     }
-}
-        ";
+}",
+                    },
+                },
+                CodeActionEquivalenceKey = "False;False;True:global::I;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            };
 
-            await TestWithAllCodeStyleOptionsOffAsync(initial, expected, index: 0);
+            test.Options.AddRange(AllOptionsOff);
+            await test.RunAsync();
         }
 
 #if false
@@ -6438,7 +6566,7 @@ public async Task TestImplementInterfaceForImplicitIDisposable()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-class Program : [|IDisposable|]
+class Program : {|CS0535:IDisposable|}
 {
 }",
 $@"using System;
@@ -6448,7 +6576,7 @@ class Program : IDisposable
     private bool disposedValue;
 
 {DisposePattern("protected virtual ", "Program", "public void ")}
-}}", index: 1);
+}}", codeAction: ("False;False;True:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -6457,7 +6585,7 @@ public async Task TestImplementInterfaceForExplicitIDisposable()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-class Program : [|IDisposable|]
+class Program : {|CS0535:IDisposable|}
 {
     private bool DisposedValue;
 }",
@@ -6469,7 +6597,7 @@ class Program : IDisposable
     private bool disposedValue;
 
 {DisposePattern("protected virtual ", "Program", "void IDisposable.")}
-}}", index: 3);
+}}", codeAction: ("True;False;False:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 3));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -6478,7 +6606,7 @@ public async Task TestImplementInterfaceForIDisposableNonApplicable1()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-class Program : [|IDisposable|]
+class Program : {|CS0535:IDisposable|}
 {
     private bool disposedValue;
 }",
@@ -6492,7 +6620,7 @@ public void Dispose()
     {
         throw new NotImplementedException();
     }
-}", index: 0);
+}", codeAction: ("False;False;True:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 0));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -6501,7 +6629,7 @@ public async Task TestImplementInterfaceForIDisposableNonApplicable2()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-class Program : [|IDisposable|]
+class Program : {|CS0535:IDisposable|}
 {
     public void Dispose(bool flag)
     {
@@ -6519,7 +6647,7 @@ public void Dispose()
     {
         throw new NotImplementedException();
     }
-}", index: 0);
+}", codeAction: ("False;False;True:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 0));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -6528,7 +6656,7 @@ public async Task TestImplementInterfaceForExplicitIDisposableWithSealedClass()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-sealed class Program : [|IDisposable|]
+sealed class Program : {|CS0535:IDisposable|}
 {
 }",
 $@"using System;
@@ -6538,7 +6666,7 @@ sealed class Program : IDisposable
     private bool disposedValue;
 
 {DisposePattern("private ", "Program", "void IDisposable.")}
-}}", index: 3);
+}}", codeAction: ("True;False;False:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 3));
         }
 
         [WorkItem(9760, "https://github.com/dotnet/roslyn/issues/9760")]
@@ -6548,7 +6676,7 @@ public async Task TestImplementInterfaceForExplicitIDisposableWithExistingField(
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-class Program : [|IDisposable|]
+class Program : {|CS0535:IDisposable|}
 {
     private bool disposedValue;
 }",
@@ -6560,27 +6688,35 @@ class Program : IDisposable
     private bool disposedValue1;
 
 {DisposePattern("protected virtual ", "Program", "public void ", disposeField: "disposedValue1")}
-}}", index: 1);
+}}", codeAction: ("False;False;True:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 1));
         }
 
         [WorkItem(9760, "https://github.com/dotnet/roslyn/issues/9760")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementInterfaceUnderscoreNameForFields()
         {
-            await TestInRegularAndScriptAsync(
-@"using System;
+            await new VerifyCS.Test
+            {
+                TestCode = @"using System;
 
-class Program : [|IDisposable|]
+class Program : {|CS0535:IDisposable|}
 {
 }",
-$@"using System;
+                FixedCode = $@"using System;
 
 class Program : IDisposable
 {{
     private bool _disposedValue;
 
 {DisposePattern("protected virtual ", "Program", "public void ", disposeField: "_disposedValue")}
-}}", index: 1, options: _options.FieldNamesAreCamelCaseWithUnderscorePrefix);
+}}",
+                Options =
+                {
+                    _options.FieldNamesAreCamelCaseWithUnderscorePrefix,
+                },
+                CodeActionEquivalenceKey = "False;False;True:global::System.IDisposable;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [WorkItem(939123, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/939123")]
@@ -6593,7 +6729,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     void M([System.Runtime.InteropServices.ComAliasName(""pAlias"")] int p);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -6623,7 +6759,7 @@ interface I
     long M([ComAliasName(""pAlias2"")] int p);
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"using System.Runtime.InteropServices;
@@ -6653,7 +6789,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     long this[[System.Runtime.InteropServices.ComAliasName(""pAlias"")] int p] { get; }
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
 @"interface I
@@ -6685,7 +6821,7 @@ public interface TestInterface
         void M1();
     }
 
-    struct TestStruct1 : [|TestInterface|]
+    struct TestStruct1 : {|CS0535:TestInterface|}{|CS1513:|}{|CS1514:|}
 
 
     // Comment
@@ -6726,7 +6862,7 @@ partial class C
 {
 }
 
-partial class C : [|I<System.Exception, System.AggregateException>|], System.IDisposable
+partial class C : {|CS0535:{|CS0535:{|CS0535:I<System.Exception, System.AggregateException>|}|}|}, {|CS0535:System.IDisposable|}
 {
 }",
 $@"using System;
@@ -6762,7 +6898,7 @@ public List<UU> M<TT, UU>(Dictionary<TT, List<UU>> a, TT b, UU c) where UU : TT
     }}
 
 {DisposePattern("protected virtual ", "C", "public void ")}
-}}", index: 1);
+}}", codeAction: ("False;False;True:global::I<global::System.Exception, global::System.AggregateException>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 1));
         }
 
         [WorkItem(994328, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/994328")]
@@ -6776,7 +6912,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     System.Collections.Generic.List<UU> M<TT, UU>(System.Collections.Generic.Dictionary<TT, System.Collections.Generic.List<UU>> a, TT b, UU c) where UU : TT;
 }
 
-partial class C : [|I<System.Exception, System.AggregateException>|], System.IDisposable
+partial class C : {|CS0535:{|CS0535:{|CS0535:I<System.Exception, System.AggregateException>|}|}|}, {|CS0535:System.IDisposable|}
 {
 }
 
@@ -6816,7 +6952,7 @@ List<UU> I<Exception, AggregateException>.M<TT, UU>(Dictionary<TT, List<UU>> a,
 
 partial class C
 {{
-}}", index: 3);
+}}", codeAction: ("True;False;False:global::I<global::System.Exception, global::System.AggregateException>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceWithDisposePatternCodeAction;", 3));
         }
 
         private static string DisposePattern(
@@ -6863,7 +6999,7 @@ public async Task TestInaccessibleAttributes()
             await TestWithAllCodeStyleOptionsOffAsync(
 @"using System;
 
-public class Goo : [|Holder.SomeInterface|]
+public class Goo : {|CS0535:Holder.SomeInterface|}
 {
 }
 
@@ -6911,7 +7047,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
 using System.Linq;
 using System.Threading.Tasks;
 
-class Issue2785<T> : [|IList<object>|]
+class Issue2785<T> : {|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:{|CS0535:IList<object>|}|}|}|}|}|}|}|}|}|}|}|}|}
 {
     private static List<object> innerList = new List<object>();
 }",
@@ -7004,7 +7140,7 @@ IEnumerator IEnumerable.GetEnumerator()
         return ((IEnumerable)innerList).GetEnumerator();
     }
 }",
-index: 1);
+codeAction: ("False;False;False:global::System.Collections.Generic.IList<object>;mscorlib;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;innerList", 1));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface), CompilerTrait(CompilerFeature.Tuples)]
@@ -7016,7 +7152,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     (int, string, int, string, int, string, int, string) Method1((int, string, int, string, int, string, int, string) y);
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
     (int, string) x;
 }",
@@ -7045,7 +7181,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     (int a, string b, int c, string d, int e, string f, int g, string h) Method1((int a, string b, int c, string d, int e, string f, int g, string h) y);
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
     (int, string) x;
 }",
@@ -7074,7 +7210,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     (TA, TB) Method1((TA, TB) y);
 }
 
-class Class : [|IInterface<(int, string), int>|]
+class Class : {|CS0535:IInterface<(int, string), int>|}
 {
     (int, string) x;
 }",
@@ -7103,7 +7239,7 @@ await TestWithAllCodeStyleOptionsOffAsync(
     (TA a, TB b) Method1((TA a, TB b) y);
 }
 
-class Class : [|IInterface<(int, string), int>|]
+class Class : {|CS0535:IInterface<(int, string), int>|}
 {
     (int, string) x;
 }",
@@ -7127,17 +7263,18 @@ class Class : IInterface<(int, string), int>
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestWithGroupingOff1()
         {
-            await TestInRegularAndScriptAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                TestCode = @"interface IInterface
 {
     int Prop { get; }
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
     void M() { }
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     int Prop { get; }
 }
@@ -7147,7 +7284,12 @@ class Class : IInterface
     void M() { }
 
     public int Prop => throw new System.NotImplementedException();
-}", options: Option(ImplementTypeOptions.InsertionBehavior, ImplementTypeInsertionBehavior.AtTheEnd));
+}",
+                Options =
+                {
+                    { ImplementTypeOptions.InsertionBehavior, ImplementTypeInsertionBehavior.AtTheEnd },
+                },
+            }.RunAsync();
         }
 
         [WorkItem(15387, "https://github.com/dotnet/roslyn/issues/15387")]
@@ -7159,6 +7301,7 @@ await TestInRegularAndScriptAsync(
 using System.Runtime.InteropServices;
 
 [ComImport]
+[Guid(""00000000-0000-0000-0000-000000000000"")]
 interface IComInterface
 {
     void MOverload();
@@ -7167,13 +7310,14 @@ interface IComInterface
     int Prop { get; }
 }
 
-class Class : [|IComInterface|]
+class Class : {|CS0535:{|CS0535:{|CS0535:{|CS0535:IComInterface|}|}|}|}
 {
 }",
 @"
 using System.Runtime.InteropServices;
 
 [ComImport]
+[Guid(""00000000-0000-0000-0000-000000000000"")]
 interface IComInterface
 {
     void MOverload();
@@ -7207,11 +7351,15 @@ public void MOverload(int i)
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestDoNotReorderComImportMembers_02()
         {
-            await TestInRegularAndScriptAsync(
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode =
 @"
 using System.Runtime.InteropServices;
 
 [ComImport]
+[Guid(""00000000-0000-0000-0000-000000000000"")]
 interface IComInterface
 {
     void MOverload() { }
@@ -7220,13 +7368,15 @@ void MOverload(int i) { }
     int Prop { get; }
 }
 
-class Class : [|IComInterface|]
+class Class : {|CS0535:IComInterface|}
 {
 }",
+                FixedCode =
 @"
 using System.Runtime.InteropServices;
 
 [ComImport]
+[Guid(""00000000-0000-0000-0000-000000000000"")]
 interface IComInterface
 {
     void MOverload() { }
@@ -7238,7 +7388,8 @@ void MOverload(int i) { }
 class Class : IComInterface
 {
     public int Prop => throw new System.NotImplementedException();
-}");
+}",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -7254,7 +7405,7 @@ interface I {
     ref int this[int i] { get; }
 }
 
-class C : [|I|]
+class C : {|CS0535:{|CS0535:{|CS0535:I|}|}|}
 {
 }",
 @"
@@ -7284,18 +7435,19 @@ public ref int IGoo()
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestAutoProperties()
         {
-            await TestInRegularAndScript1Async(
-@"interface IInterface
+            await new VerifyCS.Test()
+            {
+                TestCode = @"interface IInterface
 {
     int ReadOnlyProp { get; }
     int ReadWriteProp { get; set; }
     int WriteOnlyProp { set; }
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     int ReadOnlyProp { get; }
     int ReadWriteProp { get; set; }
@@ -7307,16 +7459,21 @@ class Class : IInterface
     public int ReadOnlyProp { get; }
     public int ReadWriteProp { get; set; }
     public int WriteOnlyProp { set => throw new System.NotImplementedException(); }
-}", parameters: new TestParameters(options: Option(
-    ImplementTypeOptions.PropertyGenerationBehavior,
-    ImplementTypePropertyGenerationBehavior.PreferAutoProperties)));
+}",
+                Options =
+                {
+                    { ImplementTypeOptions.PropertyGenerationBehavior, ImplementTypePropertyGenerationBehavior.PreferAutoProperties },
+                },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestOptionalParameterWithDefaultLiteral()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.CSharp7_1,
+                TestCode = @"
 using System.Threading;
 
 interface IInterface
@@ -7324,10 +7481,10 @@ interface IInterface
     void Method1(CancellationToken cancellationToken = default(CancellationToken));
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
-@"
+                FixedCode = @"
 using System.Threading;
 
 interface IInterface
@@ -7341,7 +7498,9 @@ public void Method1(CancellationToken cancellationToken = default)
     {
         throw new System.NotImplementedException();
     }
-}", parseOptions: CSharp7_1);
+}",
+                Options = { AllOptionsOff },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -7352,7 +7511,7 @@ await TestInRegularAndScriptAsync(
 {
     void Method(in int p);
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"interface ITest
@@ -7376,7 +7535,7 @@ await TestInRegularAndScriptAsync(
 {
     ref readonly int Method();
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"interface ITest
@@ -7400,7 +7559,7 @@ await TestInRegularAndScriptAsync(
 {
     ref readonly int Property { get; }
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"interface ITest
@@ -7421,7 +7580,7 @@ await TestInRegularAndScriptAsync(
 {
     int this[in int p] { set; }
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"interface ITest
@@ -7442,7 +7601,7 @@ await TestInRegularAndScriptAsync(
 {
     ref readonly int this[int p] { get; }
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"interface ITest
@@ -7463,7 +7622,7 @@ await TestInRegularAndScriptAsync(
 {
     void M<T>() where T : unmanaged;
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"public interface ITest
@@ -7482,8 +7641,10 @@ public void M<T>() where T : unmanaged
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestSealedMember_01()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7491,10 +7652,10 @@ sealed void M1() {}
     sealed int P1 => 1;
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -7508,14 +7669,18 @@ public void Method1()
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+                Options = { AllOptionsOff },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestSealedMember_02()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7523,10 +7688,10 @@ sealed void M1() {}
     sealed int P1 => 1;
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -7541,14 +7706,19 @@ void IInterface.Method1()
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "True;False;False:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestSealedMember_03()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7556,10 +7726,10 @@ sealed void M1() {}
     sealed int P1 => 1;
 }
 
-abstract class Class : [|IInterface|]
+abstract class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -7571,14 +7741,19 @@ abstract class Class : IInterface
 {
     public abstract void Method1();
 }",
-index: 1);
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "False;True;True:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestNonPublicMember_01()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7586,10 +7761,14 @@ await TestWithAllCodeStyleOptionsOffAsync(
     protected int P1 {get;}
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
 {
 }",
-@"interface IInterface
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface IInterface
 {
     void Method1();
 
@@ -7597,29 +7776,41 @@ class Class : [|IInterface|]
     protected int P1 {get;}
 }
 
-class Class : IInterface
+class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     public void Method1()
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "False;False;True:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestNonPublicMember_02()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     protected void M1();
     protected int P1 {get;}
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
 }",
-@"interface IInterface
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface IInterface
 {
     protected void M1();
     protected int P1 {get;}
@@ -7640,14 +7831,24 @@ void IInterface.M1()
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                DiagnosticSelector = diagnostics => diagnostics[1],
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne,
+                CodeActionEquivalenceKey = "True;False;False:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestNonPublicMember_03()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7655,10 +7856,14 @@ await TestWithAllCodeStyleOptionsOffAsync(
     protected int P1 {get;}
 }
 
-abstract class Class : [|IInterface|]
+abstract class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
 {
 }",
-@"interface IInterface
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface IInterface
 {
     void Method1();
 
@@ -7666,18 +7871,25 @@ abstract class Class : [|IInterface|]
     protected int P1 {get;}
 }
 
-abstract class Class : IInterface
+abstract class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     public abstract void Method1();
 }",
-index: 1);
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "False;True;True:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestNonPublicAccessor_01()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7685,10 +7897,14 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int P2 {protected get; set;}
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
 {
 }",
-@"interface IInterface
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface IInterface
 {
     void Method1();
 
@@ -7696,29 +7912,41 @@ class Class : [|IInterface|]
     int P2 {protected get; set;}
 }
 
-class Class : IInterface
+class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     public void Method1()
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "False;False;True:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestNonPublicAccessor_02()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     int P1 {get; protected set;}
     int P2 {protected get; set;}
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
 }",
-@"interface IInterface
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface IInterface
 {
     int P1 {get; protected set;}
     int P2 {protected get; set;}
@@ -7751,14 +7979,23 @@ int IInterface.P2
             throw new System.NotImplementedException();
         }
     }
-}");
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "True;False;False:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestNonPublicAccessor_03()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7766,10 +8003,14 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int P2 {protected get; set;}
 }
 
-abstract class Class : [|IInterface|]
+abstract class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
 {
 }",
-@"interface IInterface
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"interface IInterface
 {
     void Method1();
 
@@ -7777,18 +8018,25 @@ abstract class Class : [|IInterface|]
     int P2 {protected get; set;}
 }
 
-abstract class Class : IInterface
+abstract class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     public abstract void Method1();
 }",
-index: 1);
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "False;True;True:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestPrivateAccessor_01()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7796,10 +8044,10 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int P2 {private get => 0; set {}}
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -7813,14 +8061,18 @@ public void Method1()
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+                Options = { AllOptionsOff },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestPrivateAccessor_02()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7828,10 +8080,10 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int P2 {private get => 0; set {}}
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -7846,14 +8098,19 @@ void IInterface.Method1()
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "True;False;False:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestPrivateAccessor_03()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -7861,10 +8118,10 @@ await TestWithAllCodeStyleOptionsOffAsync(
     int P2 {private get => 0; set {}}
 }
 
-abstract class Class : [|IInterface|]
+abstract class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -7876,234 +8133,323 @@ abstract class Class : IInterface
 {
     public abstract void Method1();
 }",
-index: 1);
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "False;True;True:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestInaccessibleMember_01()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface IInterface
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
+{
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"public interface IInterface
 {
     void Method1();
 
     internal void M1();
     internal int P1 {get;}
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-class Class : [|IInterface|]
-{
-}
-        </Document>
-    </Project>
-</Workspace>",
-@"
-class Class : IInterface
+}",
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences = { "Assembly1" },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     public void Method1()
     {
         throw new System.NotImplementedException();
     }
-}
-        ");
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+
+                // Specify the code action by equivalence key only to avoid trying to implement the interface explicitly with a second code fix pass.
+                CodeActionEquivalenceKey = "False;False;True:global::IInterface;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestInaccessibleMember_02()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface IInterface
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
+{
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"public interface IInterface
 {
     void Method1();
 
     internal void M1();
     internal int P1 {get;}
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-class Class : [|IInterface|]
-{
-}
-        </Document>
-    </Project>
-</Workspace>",
-@"
-class Class : IInterface
+}",
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences = { "Assembly1" },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     void IInterface.Method1()
     {
         throw new System.NotImplementedException();
     }
-}
-        ",
-index: 1);
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "True;False;False:global::IInterface;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestInaccessibleMember_03()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface IInterface
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"abstract class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
+{
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"public interface IInterface
 {
     void Method1();
 
     internal void M1();
     internal int P1 {get;}
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-abstract class Class : [|IInterface|]
-{
-}
-        </Document>
-    </Project>
-</Workspace>",
-@"
-abstract class Class : IInterface
+}",
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences = { "Assembly1" },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"abstract class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     public abstract void Method1();
-}
-        ",
-index: 1);
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+
+                // Specify the code action by equivalence key only to avoid trying to execute a second code fix pass with a different action
+                CodeActionEquivalenceKey = "False;True;True:global::IInterface;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestInaccessibleAccessor_01()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface IInterface
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
+{
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"public interface IInterface
 {
     void Method1();
 
     int P1 {get; internal set;}
     int P2 {internal get; set;}
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-class Class : [|IInterface|]
-{
-}
-        </Document>
-    </Project>
-</Workspace>",
-@"
-class Class : IInterface
+}",
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences = { "Assembly1" },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     public void Method1()
     {
         throw new System.NotImplementedException();
     }
-}
-        ");
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+
+                // Specify the code action by equivalence key only to avoid trying to implement the interface explicitly with a second code fix pass.
+                CodeActionEquivalenceKey = "False;False;True:global::IInterface;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestInaccessibleAccessor_02()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface IInterface
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
+{
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"public interface IInterface
 {
     void Method1();
 
     int P1 {get; internal set;}
     int P2 {internal get; set;}
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-class Class : [|IInterface|]
-{
-}
-        </Document>
-    </Project>
-</Workspace>",
-@"
-class Class : IInterface
+}",
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences = { "Assembly1" },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     void IInterface.Method1()
     {
         throw new System.NotImplementedException();
     }
-}
-        ",
-index: 1);
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "True;False;False:global::IInterface;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestInaccessibleAccessor_03()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface IInterface
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"abstract class Class : {|CS0535:{|CS0535:{|CS0535:IInterface|}|}|}
+{
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"public interface IInterface
 {
     void Method1();
 
     int P1 {get; internal set;}
     int P2 {internal get; set;}
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-abstract class Class : [|IInterface|]
-{
-}
-        </Document>
-    </Project>
-</Workspace>",
-@"
-abstract class Class : IInterface
+}",
+                            },
+                        },
+                    },
+                    AdditionalProjectReferences = { "Assembly1" },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"abstract class Class : {|CS0535:{|CS0535:IInterface|}|}
 {
     public abstract void Method1();
-}
-        ",
-index: 1);
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                Options = { AllOptionsOff },
+
+                // Specify the code action by equivalence key only to avoid trying to execute a second code fix pass with a different action
+                CodeActionEquivalenceKey = "False;True;True:global::IInterface;Assembly1;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestVirtualMember_01()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -8111,10 +8457,10 @@ virtual void M1() {}
     virtual int P1 => 1;
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -8128,14 +8474,18 @@ public void Method1()
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+                Options = { AllOptionsOff },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestVirtualMember_02()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -8143,10 +8493,10 @@ virtual void M1() {}
     virtual int P1 => 1;
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -8161,14 +8511,19 @@ void IInterface.Method1()
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "True;False;False:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestVirtualMember_03()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -8176,10 +8531,10 @@ virtual void M1() {}
     virtual int P1 => 1;
 }
 
-abstract class Class : [|IInterface|]
+abstract class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -8191,14 +8546,19 @@ abstract class Class : IInterface
 {
     public abstract void Method1();
 }",
-index: 1);
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "False;True;True:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestStaticMember_01()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -8208,10 +8568,10 @@ static void M1() {}
     public abstract class C {}
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -8227,14 +8587,18 @@ public void Method1()
     {
         throw new System.NotImplementedException();
     }
-}");
+}",
+                Options = { AllOptionsOff },
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestStaticMember_02()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -8244,10 +8608,10 @@ static void M1() {}
     public abstract class C {}
 }
 
-class Class : [|IInterface|]
+class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -8264,14 +8628,19 @@ void IInterface.Method1()
         throw new System.NotImplementedException();
     }
 }",
-index: 1);
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "True;False;False:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestStaticMember_03()
         {
-            await TestWithAllCodeStyleOptionsOffAsync(
-@"interface IInterface
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"interface IInterface
 {
     void Method1();
 
@@ -8281,10 +8650,10 @@ static void M1() {}
     public abstract class C {}
 }
 
-abstract class Class : [|IInterface|]
+abstract class Class : {|CS0535:IInterface|}
 {
 }",
-@"interface IInterface
+                FixedCode = @"interface IInterface
 {
     void Method1();
 
@@ -8298,7 +8667,10 @@ abstract class Class : IInterface
 {
     public abstract void Method1();
 }",
-index: 1);
+                Options = { AllOptionsOff },
+                CodeActionEquivalenceKey = "False;True;True:global::IInterface;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -8309,7 +8681,7 @@ await TestInRegularAndScriptAsync(
 {
     void M<T>() where T : notnull;
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"public interface ITest
@@ -8335,7 +8707,7 @@ public interface ITest
 {
     string? P { get; }
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"#nullable enable 
@@ -8353,17 +8725,18 @@ public class Test : ITest
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestWithNullablePropertyAlreadyImplemented()
         {
-            await TestMissingAsync(
+            var code =
 @"#nullable enable 
 
 public interface ITest
 {
     string? P { get; }
 }
-public class Test : [|ITest|]
+public class Test : ITest
 {
     public string? P => throw new System.NotImplementedException();
-}");
+}";
+            await VerifyCS.VerifyCodeFixAsync(code, code);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -8376,7 +8749,7 @@ public interface ITest
 {
     string? P();
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"#nullable enable 
@@ -8408,7 +8781,7 @@ public interface ITest
 {
     event EventHandler? SomeEvent;
 }
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"#nullable enable 
@@ -8438,7 +8811,7 @@ public interface ITest
 
 #nullable disable
 
-public class Test : [|ITest|]
+public class Test : {|CS0535:ITest|}
 {
 }",
 @"#nullable enable 
@@ -8459,54 +8832,53 @@ public class Test : ITest
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task GenericInterfaceNotNull1()
         {
-            await TestInRegularAndScriptAsync(
-@$"#nullable enable 
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                TestCode = @"#nullable enable 
 
 using System.Diagnostics.CodeAnalysis;
 
-{NullableAttributesCode}
-
 interface IFoo<T>
-{{
+{
     [return: NotNull]
     T Bar([DisallowNull] T bar);
 
     [return: MaybeNull]
     T Baz([AllowNull] T bar);
-}}
+}
 
-class A : [|IFoo<int>|]
-{{
-}}",
-@$"#nullable enable 
+class A : {|CS0535:{|CS0535:IFoo<int>|}|}
+{
+}",
+                FixedCode = @"#nullable enable 
 
 using System.Diagnostics.CodeAnalysis;
 
-{NullableAttributesCode}
-
 interface IFoo<T>
-{{
+{
     [return: NotNull]
     T Bar([DisallowNull] T bar);
 
     [return: MaybeNull]
     T Baz([AllowNull] T bar);
-}}
+}
 
-class A : [|IFoo<int>|]
-{{
+class A : IFoo<int>
+{
     [return: NotNull]
     public int Bar([DisallowNull] int bar)
-    {{
+    {
         throw new System.NotImplementedException();
-    }}
+    }
 
     [return: MaybeNull]
     public int Baz([AllowNull] int bar)
-    {{
+    {
         throw new System.NotImplementedException();
-    }}
-}}");
+    }
+}",
+            }.RunAsync();
         }
 
         [WorkItem(13427, "https://github.com/dotnet/roslyn/issues/13427")]
@@ -8524,7 +8896,7 @@ interface I
     void M();
 }
 
-class D : B, [|I|]
+class D : B, {|CS0535:I|}
 {
 }",
 @"class B
@@ -8556,7 +8928,7 @@ interface I
     void M2();
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
     public void M1(){}
 }",
@@ -8567,7 +8939,7 @@ interface I
     void M2();
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
     public void M1(){}
 
@@ -8575,64 +8947,94 @@ void I.M2()
     {
         throw new System.NotImplementedException();
     }
-}", index: 2);
+}", codeAction: ("True;False;True:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 2));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task ImplementInitOnlyProperty()
         {
-            await TestInRegularAndScriptAsync(@"
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.CSharp9,
+                TestCode = @"
 interface I
 {
     int Property { get; init; }
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
 }",
-@"
+                FixedCode = @"
 interface I
 {
     int Property { get; init; }
 }
 
-class C : [|I|]
+class C : I
 {
     public int Property { get => throw new System.NotImplementedException(); init => throw new System.NotImplementedException(); }
-}");
+}",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task ImplementRemainingExplicitlyMissingWhenAllImplemented()
         {
-            await TestActionCountAsync(@"
+            var code = @"
 interface I
 {
     void M1();
     void M2();
 }
 
-class C : [|I|]
+class C : I
 {
     public void M1(){}
     public void M2(){}
-}", 0);
+}";
+
+            await VerifyCS.VerifyCodeFixAsync(code, code);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task ImplementRemainingExplicitlyMissingWhenAllImplementedAreExplicit()
         {
-            await TestActionCountAsync(@"
+            var code = @"
 interface I
 {
     void M1();
     void M2();
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
     void I.M1(){}
-}", 2);
+}";
+            var fixedCode = @"
+interface I
+{
+    void M1();
+    void M2();
+}
+
+class C : I
+{
+    public void M2()
+    {
+        throw new System.NotImplementedException();
+    }
+
+    void I.M1(){}
+}";
+
+            await new VerifyCS.Test
+            {
+                TestCode = code,
+                FixedCode = fixedCode,
+                CodeActionsVerifier = codeActions => Assert.Equal(2, codeActions.Length),
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
@@ -8645,7 +9047,7 @@ interface I
     internal void M2();
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
     public void M1(){}
 }",
@@ -8656,7 +9058,7 @@ interface I
     internal void M2();
 }
 
-class C : [|I|]
+class C : {|CS0535:I|}
 {
     public void M1(){}
 
@@ -8664,63 +9066,73 @@ void I.M2()
     {
         throw new System.NotImplementedException();
     }
-}", index: 1);
+}", codeAction: ("True;False;True:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(48295, "https://github.com/dotnet/roslyn/issues/48295")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementOnRecord_WithSemiColon()
         {
-            await TestInRegularAndScriptAsync(@"
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
 interface I
 {
     void M1();
 }
 
-record C : [|I|];
+record C : {|CS0535:I|};
 ",
-@"
+                FixedCode = @"
 interface I
 {
     void M1();
 }
 
-record C : [|I|]
+record C : {|CS0535:I|}
 {
     public void M1()
     {
         throw new System.NotImplementedException();
     }
 }
-");
+",
+            }.RunAsync();
         }
 
         [WorkItem(48295, "https://github.com/dotnet/roslyn/issues/48295")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementOnRecord_WithBracesAndTrivia()
         {
-            await TestInRegularAndScriptAsync(@"
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
 interface I
 {
     void M1();
 }
 
-record C : [|I|] { } // hello
+record C : {|CS0535:I|} { } // hello
 ",
-@"
+                FixedCode = @"
 interface I
 {
     void M1();
 }
 
-record C : [|I|]
+record C : {|CS0535:I|}
 {
     public void M1()
     {
         throw new System.NotImplementedException();
     }
 } // hello
-");
+",
+            }.RunAsync();
         }
 
         [WorkItem(48295, "https://github.com/dotnet/roslyn/issues/48295")]
@@ -8730,45 +9142,53 @@ public void M1()
         [InlineData("record struct")]
         public async Task TestImplementOnRecord_WithSemiColonAndTrivia(string record)
         {
-            await TestInRegularAndScriptAsync($@"
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = $@"
 interface I
 {{
     void M1();
 }}
 
-{record} C : [|I|]; // hello
+{record} C : {{|CS0535:I|}}; // hello
 ",
-$@"
+                FixedCode = $@"
 interface I
 {{
     void M1();
 }}
 
-{record} C : [|I|] // hello
+{record} C : {{|CS0535:I|}} // hello
 {{
     public void M1()
     {{
         throw new System.NotImplementedException();
     }}
 }}
-");
+",
+            }.RunAsync();
         }
 
         [WorkItem(49019, "https://github.com/dotnet/roslyn/issues/49019")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestUnconstrainedGenericInstantiatedWithValueType()
         {
-            await TestInRegularAndScriptAsync(@"
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.CSharp9,
+                TestCode = @"#nullable enable
 interface IGoo<T>
 {
     void Bar(T? x);
 }
 
-class C : [|IGoo<int>|]
+class C : {|CS0535:IGoo<int>|}
 {
 }
 ",
-@"
+                FixedCode = @"#nullable enable
 interface IGoo<T>
 {
     void Bar(T? x);
@@ -8781,7 +9201,8 @@ public void Bar(int x)
         throw new System.NotImplementedException();
     }
 }
-");
+",
+            }.RunAsync();
         }
 
         [WorkItem(49019, "https://github.com/dotnet/roslyn/issues/49019")]
@@ -8794,7 +9215,7 @@ interface IGoo<T> where T : struct
     void Bar(T? x);
 }
 
-class C : [|IGoo<int>|]
+class C : {|CS0535:IGoo<int>|}
 {
 }
 ",
@@ -8818,20 +9239,27 @@ public void Bar(int? x)
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestUnconstrainedGenericInstantiatedWithReferenceType()
         {
-            await TestInRegularAndScriptAsync(@"
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.CSharp9,
+                TestCode = @"
 interface IGoo<T>
 {
+#nullable enable
     void Bar(T? x);
+#nullable restore
 }
 
-class C : [|IGoo<string>|]
+class C : {|CS0535:IGoo<string>|}
 {
 }
 ",
-@"
+                FixedCode = @"
 interface IGoo<T>
 {
+#nullable enable
     void Bar(T? x);
+#nullable restore
 }
 
 class C : IGoo<string>
@@ -8841,14 +9269,18 @@ public void Bar(string x)
         throw new System.NotImplementedException();
     }
 }
-");
+",
+            }.RunAsync();
         }
 
         [WorkItem(49019, "https://github.com/dotnet/roslyn/issues/49019")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestUnconstrainedGenericInstantiatedWithReferenceType_NullableEnable()
         {
-            await TestInRegularAndScriptAsync(@"
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.CSharp9,
+                TestCode = @"
 #nullable enable
 
 interface IGoo<T>
@@ -8856,11 +9288,11 @@ interface IGoo<T>
     void Bar(T? x);
 }
 
-class C : [|IGoo<string>|]
+class C : {|CS0535:IGoo<string>|}
 {
 }
 ",
-@"
+                FixedCode = @"
 #nullable enable
 
 interface IGoo<T>
@@ -8875,24 +9307,30 @@ public void Bar(string? x)
         throw new System.NotImplementedException();
     }
 }
-");
+",
+            }.RunAsync();
         }
 
         [WorkItem(49019, "https://github.com/dotnet/roslyn/issues/49019")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestConstrainedGenericInstantiatedWithReferenceType()
         {
-            await TestInRegularAndScriptAsync(@"
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.CSharp9,
+                TestCode = @"
+#nullable enable
 interface IGoo<T> where T : class
 {
     void Bar(T? x);
 }
 
-class C : [|IGoo<string>|]
+class C : {|CS0535:IGoo<string>|}
 {
 }
 ",
-@"
+                FixedCode = @"
+#nullable enable
 interface IGoo<T> where T : class
 {
     void Bar(T? x);
@@ -8900,12 +9338,13 @@ interface IGoo<T> where T : class
 
 class C : IGoo<string>
 {
-    public void Bar(string x)
+    public void Bar(string? x)
     {
         throw new System.NotImplementedException();
     }
 }
-");
+",
+            }.RunAsync();
         }
 
         [WorkItem(49019, "https://github.com/dotnet/roslyn/issues/49019")]
@@ -8920,7 +9359,7 @@ interface IGoo<T> where T : class
     void Bar(T? x);
 }
 
-class C : [|IGoo<string>|]
+class C : {|CS0535:IGoo<string>|}
 {
 }
 ",
@@ -8946,18 +9385,21 @@ public void Bar(string? x)
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestImplementTwoPropertiesOfCSharp5()
         {
-            await TestInRegularAndScriptAsync(@"
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.CSharp5,
+                TestCode = @"
 interface ITest
 {
     int Bar { get; }
     int Foo { get; }
 }
 
-class Program : [|ITest|]
+class Program : {|CS0535:{|CS0535:ITest|}|}
 {
 }
 ",
-@"
+                FixedCode = @"
 interface ITest
 {
     int Bar { get; }
@@ -8982,7 +9424,459 @@ public int Foo
         }
     }
 }
-", parseOptions: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5));
+",
+            }.RunAsync();
+        }
+
+        [WorkItem(53925, "https://github.com/dotnet/roslyn/issues/53925")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterfaceMember()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest
+{
+    static abstract void M1();
+}
+
+class C : {|CS0535:ITest|}
+{
+}
+",
+                FixedCode = @"
+interface ITest
+{
+    static abstract void M1();
+}
+
+class C : ITest
+{
+    public static void M1()
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_interface, codeAction.Title),
+                CodeActionEquivalenceKey = "False;False;True:global::ITest;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            }.RunAsync();
+        }
+
+        [WorkItem(53925, "https://github.com/dotnet/roslyn/issues/53925")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterfaceMemberExplicitly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest
+{
+    static abstract void M1();
+}
+
+class C : {|CS0535:ITest|}
+{
+}
+",
+                FixedCode = @"
+interface ITest
+{
+    static abstract void M1();
+}
+
+class C : ITest
+{
+    static void ITest.M1()
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_all_members_explicitly, codeAction.Title),
+                CodeActionEquivalenceKey = "True;False;False:global::ITest;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
+        }
+
+        [WorkItem(53925, "https://github.com/dotnet/roslyn/issues/53925")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterfaceMember_ImplementAbstractly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest
+{
+    static abstract void M1();
+}
+
+abstract class C : {|CS0535:ITest|}
+{
+}
+",
+                FixedCode = @"
+interface ITest
+{
+    static abstract void M1();
+}
+
+abstract class C : ITest
+{
+    public static void M1()
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_interface_abstractly, codeAction.Title),
+                CodeActionEquivalenceKey = "False;True;True:global::ITest;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
+        }
+
+        [WorkItem(53927, "https://github.com/dotnet/roslyn/issues/53927")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterfaceOperator_OnlyExplicitlyImplementable()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest
+{
+    static abstract int operator -(ITest x);
+}
+class C : {|CS0535:ITest|}
+{
+}
+",
+                FixedCode = @"
+interface ITest
+{
+    static abstract int operator -(ITest x);
+}
+class C : ITest
+{
+    static int ITest.operator -(ITest x)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_all_members_explicitly, codeAction.Title),
+                CodeActionEquivalenceKey = "True;False;False:global::ITest;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            }.RunAsync();
+        }
+
+        [WorkItem(53927, "https://github.com/dotnet/roslyn/issues/53927")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterfaceOperator_ImplementImplicitly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int operator -(T x);
+    static abstract int operator -(T x, int y);
+}
+class C : {|CS0535:{|CS0535:ITest<C>|}|}
+{
+}
+",
+                FixedCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int operator -(T x);
+    static abstract int operator -(T x, int y);
+}
+class C : ITest<C>
+{
+    public static int operator -(C x)
+    {
+        throw new System.NotImplementedException();
+    }
+
+    public static int operator -(C x, int y)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_interface, codeAction.Title),
+                CodeActionEquivalenceKey = "False;False;True:global::ITest<global::C>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            }.RunAsync();
+        }
+
+        [WorkItem(53927, "https://github.com/dotnet/roslyn/issues/53927")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterfaceOperator_ImplementExplicitly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int operator -(T x);
+}
+class C : {|CS0535:ITest<C>|}
+{
+}
+",
+                FixedCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int operator -(T x);
+}
+class C : ITest<C>
+{
+    static int ITest<C>.operator -(C x)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_all_members_explicitly, codeAction.Title),
+                CodeActionEquivalenceKey = "True;False;False:global::ITest<global::C>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
+        }
+
+        [WorkItem(53927, "https://github.com/dotnet/roslyn/issues/53927")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterfaceOperator_ImplementAbstractly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int operator -(T x);
+}
+abstract class C : {|CS0535:ITest<C>|}
+{
+}
+",
+                FixedCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int operator -(T x);
+}
+abstract class C : ITest<C>
+{
+    public static int operator -(C x)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_interface_abstractly, codeAction.Title),
+                CodeActionEquivalenceKey = "False;True;True:global::ITest<global::C>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+
+            }.RunAsync();
+        }
+
+        [WorkItem(53927, "https://github.com/dotnet/roslyn/issues/53927")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterface_Explicitly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest
+{
+    static abstract int M(ITest x);
+}
+class C : {|CS0535:ITest|}
+{
+}
+",
+                FixedCode = @"
+interface ITest
+{
+    static abstract int M(ITest x);
+}
+class C : ITest
+{
+    static int ITest.M(ITest x)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_all_members_explicitly, codeAction.Title),
+                CodeActionEquivalenceKey = "True;False;False:global::ITest;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+
+            }.RunAsync();
+        }
+
+        [WorkItem(53927, "https://github.com/dotnet/roslyn/issues/53927")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterface_Implicitly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest
+{
+    static abstract int M(ITest x);
+}
+class C : {|CS0535:ITest|}
+{
+}
+",
+                FixedCode = @"
+interface ITest
+{
+    static abstract int M(ITest x);
+}
+class C : ITest
+{
+    public static int M(ITest x)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_interface, codeAction.Title),
+                CodeActionEquivalenceKey = "False;False;True:global::ITest;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+
+            }.RunAsync();
+        }
+
+        [WorkItem(53927, "https://github.com/dotnet/roslyn/issues/53927")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterface_ImplementImplicitly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int M(T x);
+}
+class C : {|CS0535:ITest<C>|}
+{
+}
+",
+                FixedCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int M(T x);
+}
+class C : ITest<C>
+{
+    public static int M(C x)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_interface, codeAction.Title),
+                CodeActionEquivalenceKey = "False;False;True:global::ITest<global::C>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+
+            }.RunAsync();
+        }
+
+        [WorkItem(53927, "https://github.com/dotnet/roslyn/issues/53927")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterface_ImplementExplicitly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int M(T x);
+}
+class C : {|CS0535:ITest<C>|}
+{
+}
+",
+                FixedCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int M(T x);
+}
+class C : ITest<C>
+{
+    static int ITest<C>.M(C x)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_all_members_explicitly, codeAction.Title),
+                CodeActionEquivalenceKey = "True;False;False:global::ITest<global::C>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+
+            }.RunAsync();
+        }
+
+        [WorkItem(53927, "https://github.com/dotnet/roslyn/issues/53927")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestStaticAbstractInterface_ImplementAbstractly()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int M(T x);
+}
+abstract class C : {|CS0535:ITest<C>|}
+{
+}
+",
+                FixedCode = @"
+interface ITest<T> where T : ITest<T>
+{
+    static abstract int M(T x);
+}
+abstract class C : ITest<C>
+{
+    public static int M(C x)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+",
+                CodeActionVerifier = (codeAction, verifier) => verifier.Equal(FeaturesResources.Implement_interface_abstractly, codeAction.Title),
+                CodeActionEquivalenceKey = "False;True;True:global::ITest<global::C>;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+
+            }.RunAsync();
         }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests_FixAllTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests_FixAllTests.cs
index 7bdfffaf01dbd..71951cbf5097b 100644
--- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests_FixAllTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests_FixAllTests.cs
@@ -2,16 +2,17 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.Testing;
 using Xunit;
-using ImplementInterfaceCodeAction = Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService.ImplementInterfaceCodeAction;
+using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeFixVerifier<
+    Microsoft.CodeAnalysis.Testing.EmptyDiagnosticAnalyzer,
+    Microsoft.CodeAnalysis.CSharp.ImplementInterface.CSharpImplementInterfaceCodeFixProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ImplementInterface
 {
-    public partial class ImplementInterfaceTests
+    public class ImplementInterfaceTests_FixAllTests
     {
         #region "Fix all occurrences tests"
 
@@ -20,11 +21,13 @@ public partial class ImplementInterfaceTests
         [Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
         public async Task TestFixAllInDocument()
         {
-            var input = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface I1
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
 {
     void F1();
 }
@@ -34,40 +37,75 @@ public interface I2
     void F1();
 }
 
-class B1 : {|FixAllInDocument:I1|}, I2
+class B1 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C1 : I1, I2
+    class C1 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
-}
-        </Document>
-        <Document>
-class B2 : I1, I2
+}",
+                        @"class B2 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C2 : I1, I2
+    class C2 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-class B3 : I1, I2
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"class B3 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C3 : I1, I2
+    class C3 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
+}",
+                            },
+                            AdditionalProjectReferences = { "TestProject" },
+                        },
+                    },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
+{
+    void F1();
 }
-        </Document>
-    </Project>
-</Workspace>";
 
-            var expected = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface I1
+public interface I2
+{
+    void F1();
+}
+
+class B1 : I1, I2
+{
+    public void F1()
+    {
+        throw new System.NotImplementedException();
+    }
+
+    class C1 : {|CS0535:I1|}, {|CS0535:I2|}
+    {
+    }
+}",
+                        @"class B2 : {|CS0535:I1|}, {|CS0535:I2|}
+{
+    class C2 : {|CS0535:I1|}, {|CS0535:I2|}
+    {
+    }
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                BatchFixedState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
 {
     void F1();
 }
@@ -91,31 +129,20 @@ public void F1()
             throw new System.NotImplementedException();
         }
     }
-}
-        </Document>
-        <Document>
-class B2 : I1, I2
-{
-    class C2 : I1, I2
-    {
-    }
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-class B3 : I1, I2
+}",
+                        @"class B2 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C3 : I1, I2
+    class C2 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
-}
-        </Document>
-    </Project>
-</Workspace>";
-
-            await TestInRegularAndScriptAsync(input, expected);
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne | CodeFixTestBehaviors.SkipFixAllInProjectCheck | CodeFixTestBehaviors.SkipFixAllInSolutionCheck,
+                CodeActionEquivalenceKey = "False;False;True:global::I1;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            }.RunAsync();
         }
 
         [Fact]
@@ -123,11 +150,13 @@ class C3 : I1, I2
         [Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
         public async Task TestFixAllInProject()
         {
-            var input = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface I1
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
 {
     void F1();
 }
@@ -137,40 +166,75 @@ public interface I2
     void F1();
 }
 
-class B1 : {|FixAllInProject:I1|}, I2
+class B1 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C1 : I1, I2
+    class C1 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
-}
-        </Document>
-        <Document>
-class B2 : I1, I2
+}",
+                        @"class B2 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C2 : I1, I2
+    class C2 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>        
-        <Document>
-class B3 : I1, I2
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"class B3 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C3 : I1, I2
+    class C3 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
+}",
+                            },
+                            AdditionalProjectReferences = { "TestProject" },
+                        },
+                    },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
+{
+    void F1();
 }
-        </Document>
-    </Project>
-</Workspace>";
 
-            var expected = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface I1
+public interface I2
+{
+    void F1();
+}
+
+class B1 : I1, I2
+{
+    public void F1()
+    {
+        throw new System.NotImplementedException();
+    }
+
+    class C1 : {|CS0535:I1|}, {|CS0535:I2|}
+    {
+    }
+}",
+                        @"class B2 : {|CS0535:I1|}, {|CS0535:I2|}
+{
+    class C2 : {|CS0535:I1|}, {|CS0535:I2|}
+    {
+    }
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                BatchFixedState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
 {
     void F1();
 }
@@ -194,10 +258,8 @@ public void F1()
             throw new System.NotImplementedException();
         }
     }
-}
-        </Document>
-        <Document>
-class B2 : I1, I2
+}",
+                        @"class B2 : I1, I2
 {
     public void F1()
     {
@@ -211,23 +273,14 @@ public void F1()
             throw new System.NotImplementedException();
         }
     }
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-class B3 : I1, I2
-{
-    class C3 : I1, I2
-    {
-    }
-}
-        </Document>
-    </Project>
-</Workspace>";
-
-            await TestInRegularAndScriptAsync(input, expected);
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne | CodeFixTestBehaviors.SkipFixAllInDocumentCheck | CodeFixTestBehaviors.SkipFixAllInSolutionCheck,
+                CodeActionEquivalenceKey = "False;False;True:global::I1;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 0,
+            }.RunAsync();
         }
 
         [Fact]
@@ -235,11 +288,13 @@ class C3 : I1, I2
         [Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
         public async Task TestFixAllInSolution()
         {
-            var input = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface I1
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
 {
     void F1();
 }
@@ -249,40 +304,75 @@ public interface I2
     void F1();
 }
 
-class B1 : I1, {|FixAllInSolution:I2|}
+class B1 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C1 : I1, I2
+    class C1 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
-}
-        </Document>
-        <Document>
-class B2 : I1, I2
+}",
+                        @"class B2 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C2 : I1, I2
+    class C2 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-class B3 : I1, I2
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"class B3 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C3 : I1, I2
+    class C3 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
+}",
+                            },
+                            AdditionalProjectReferences = { "TestProject" },
+                        },
+                    },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
+{
+    void F1();
 }
-        </Document>
-    </Project>
-</Workspace>";
 
-            var expected = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface I1
+public interface I2
+{
+    void F1();
+}
+
+class B1 : {|CS0535:I1|}, I2
+{
+    void I2.F1()
+    {
+        throw new System.NotImplementedException();
+    }
+
+    class C1 : {|CS0535:I1|}, {|CS0535:I2|}
+    {
+    }
+}",
+                        @"class B2 : {|CS0535:I1|}, {|CS0535:I2|}
+{
+    class C2 : {|CS0535:I1|}, {|CS0535:I2|}
+    {
+    }
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                BatchFixedState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
 {
     void F1();
 }
@@ -292,63 +382,69 @@ public interface I2
     void F1();
 }
 
-class B1 : I1, I2
+class B1 : {|CS0535:I1|}, I2
 {
     void I2.F1()
     {
         throw new System.NotImplementedException();
     }
 
-    class C1 : I1, I2
+    class C1 : {|CS0535:I1|}, I2
     {
         void I2.F1()
         {
             throw new System.NotImplementedException();
         }
     }
-}
-        </Document>
-        <Document>
-class B2 : I1, I2
+}",
+                        @"class B2 : {|CS0535:I1|}, I2
 {
     void I2.F1()
     {
         throw new System.NotImplementedException();
     }
 
-    class C2 : I1, I2
+    class C2 : {|CS0535:I1|}, I2
     {
         void I2.F1()
         {
             throw new System.NotImplementedException();
         }
     }
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <ProjectReference>Assembly1</ProjectReference>
-        <Document>
-class B3 : I1, I2
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"class B3 : {|CS0535:I1|}, I2
 {
     void I2.F1()
     {
         throw new System.NotImplementedException();
     }
 
-    class C3 : I1, I2
+    class C3 : {|CS0535:I1|}, I2
     {
         void I2.F1()
         {
             throw new System.NotImplementedException();
         }
     }
-}
-        </Document>
-    </Project>
-</Workspace>";
-
-            await TestInRegularAndScriptAsync(input, expected, index: 1);
+}",
+                            },
+                            AdditionalProjectReferences = { "TestProject" },
+                        },
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne | CodeFixTestBehaviors.SkipFixAllInDocumentCheck | CodeFixTestBehaviors.SkipFixAllInProjectCheck,
+                DiagnosticSelector = diagnostics => diagnostics[1],
+                CodeActionEquivalenceKey = "True;False;False:global::I2;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         [Fact]
@@ -356,11 +452,13 @@ void I2.F1()
         [Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
         public async Task TestFixAllInSolution_DifferentAssemblyWithSameTypeName()
         {
-            var input = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface I1
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
 {
     void F1();
 }
@@ -370,25 +468,26 @@ public interface I2
     void F1();
 }
 
-class B1 : I1, {|FixAllInSolution:I2|}
+class B1 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C1 : I1, I2
+    class C1 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
-}
-        </Document>
-        <Document>
-class B2 : I1, I2
+}",
+                        @"class B2 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C2 : I1, I2
+    class C2 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <Document>
-public interface I1
+}",
+                    },
+                    AdditionalProjects =
+                    {
+                        ["Assembly1"] =
+                        {
+                            Sources =
+                            {
+                                @"public interface I1
 {
     void F1();
 }
@@ -398,21 +497,55 @@ public interface I2
     void F1();
 }
 
-class B3 : I1, I2
+class B3 : {|CS0535:I1|}, {|CS0535:I2|}
 {
-    class C3 : I1, I2
+    class C3 : {|CS0535:I1|}, {|CS0535:I2|}
     {
     }
+}",
+                            },
+                        },
+                    },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
+{
+    void F1();
+}
+
+public interface I2
+{
+    void F1();
 }
-        </Document>
-    </Project>
-</Workspace>";
 
-            var expected = @"
-<Workspace>
-    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
-        <Document>
-public interface I1
+class B1 : {|CS0535:I1|}, I2
+{
+    void I2.F1()
+    {
+        throw new System.NotImplementedException();
+    }
+
+    class C1 : {|CS0535:I1|}, {|CS0535:I2|}
+    {
+    }
+}",
+                        @"class B2 : {|CS0535:I1|}, {|CS0535:I2|}
+{
+    class C2 : {|CS0535:I1|}, {|CS0535:I2|}
+    {
+    }
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                BatchFixedState =
+                {
+                    Sources =
+                    {
+                        @"public interface I1
 {
     void F1();
 }
@@ -422,63 +555,44 @@ public interface I2
     void F1();
 }
 
-class B1 : I1, I2
+class B1 : {|CS0535:I1|}, I2
 {
     void I2.F1()
     {
         throw new System.NotImplementedException();
     }
 
-    class C1 : I1, I2
+    class C1 : {|CS0535:I1|}, I2
     {
         void I2.F1()
         {
             throw new System.NotImplementedException();
         }
     }
-}
-        </Document>
-        <Document>
-class B2 : I1, I2
+}",
+                        @"class B2 : {|CS0535:I1|}, I2
 {
     void I2.F1()
     {
         throw new System.NotImplementedException();
     }
 
-    class C2 : I1, I2
+    class C2 : {|CS0535:I1|}, I2
     {
         void I2.F1()
         {
             throw new System.NotImplementedException();
         }
     }
-}
-        </Document>
-    </Project>
-    <Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
-        <Document>
-public interface I1
-{
-    void F1();
-}
-
-public interface I2
-{
-    void F1();
-}
-
-class B3 : I1, I2
-{
-    class C3 : I1, I2
-    {
-    }
-}
-        </Document>
-    </Project>
-</Workspace>";
-
-            await TestInRegularAndScriptAsync(input, expected, index: 1);
+}",
+                    },
+                    MarkupHandling = MarkupMode.Allow,
+                },
+                CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne | CodeFixTestBehaviors.SkipFixAllInDocumentCheck | CodeFixTestBehaviors.SkipFixAllInProjectCheck,
+                DiagnosticSelector = diagnostics => diagnostics[1],
+                CodeActionEquivalenceKey = "True;False;False:global::I2;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+                CodeActionIndex = 1,
+            }.RunAsync();
         }
 
         #endregion
diff --git a/src/EditorFeatures/CSharpTest/Intents/IntentTestsBase.cs b/src/EditorFeatures/CSharpTest/Intents/IntentTestsBase.cs
index e14a8ea6bf880..e7d6f5af75de2 100644
--- a/src/EditorFeatures/CSharpTest/Intents/IntentTestsBase.cs
+++ b/src/EditorFeatures/CSharpTest/Intents/IntentTestsBase.cs
@@ -76,6 +76,7 @@ internal static async Task VerifyExpectedTextAsync(string intentName, string act
             {
                 edit.Replace(change.Span.ToSpan(), change.NewText);
             }
+
             edit.Apply();
 
             Assert.Equal(expectedText, textBuffer.CurrentSnapshot.GetText());
diff --git a/src/EditorFeatures/CSharpTest/InvertIf/InvertIfTests.cs b/src/EditorFeatures/CSharpTest/InvertIf/InvertIfTests.cs
index b54438aba8621..fcbab10496bcc 100644
--- a/src/EditorFeatures/CSharpTest/InvertIf/InvertIfTests.cs
+++ b/src/EditorFeatures/CSharpTest/InvertIf/InvertIfTests.cs
@@ -1037,5 +1037,100 @@ await TestInRegularAndScriptAsync(
 @"class C { void M(object o) { [||]if (o is C) { a(); } else { } } }",
 @"class C { void M(object o) { if (o is not C) { } else { a(); } } }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInvertIf)]
+        [WorkItem(43224, "https://github.com/dotnet/roslyn/issues/43224")]
+        public async Task TestEmptyIf()
+        {
+            await TestInRegularAndScriptAsync(
+                @"class C { void M(string s){ [||]if (s == ""a""){}else{ s = ""b""}}}",
+                @"class C { void M(string s){ if (s != ""a""){ s = ""b""}}}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInvertIf)]
+        [WorkItem(43224, "https://github.com/dotnet/roslyn/issues/43224")]
+        public async Task TestOnlySingleLineCommentIf()
+        {
+            await TestInRegularAndScriptAsync(
+                @"
+class C 
+{
+    void M(string s)
+    {
+        [||]if (s == ""a"")
+        {
+            // A single line comment
+        }
+        else
+        {
+            s = ""b""
+        }
+    }
+}",
+                @"
+class C 
+{
+    void M(string s)
+    {
+        if (s != ""a"")
+        {
+            s = ""b""
+        }
+        else
+        {
+            // A single line comment
+        }
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInvertIf)]
+        [WorkItem(43224, "https://github.com/dotnet/roslyn/issues/43224")]
+        public async Task TestOnlyMultilineLineCommentIf()
+        {
+            await TestInRegularAndScriptAsync(
+                @"
+class C 
+{ 
+    void M(string s)
+    {
+        [||]if (s == ""a"")
+        {
+            /*
+            * This is
+            * a multiline
+            * comment with
+            * two words
+            * per line.
+            */
+        }
+        else
+        {
+            s = ""b""
+        }
+    }
+}",
+                @"
+class C 
+{ 
+    void M(string s)
+    {
+        if (s != ""a"")
+        {
+            s = ""b""
+        }
+        else
+        {
+            /*
+            * This is
+            * a multiline
+            * comment with
+            * two words
+            * per line.
+            */
+        }
+    }
+}");
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
index 4973fdf7d92fe..3e663dcaa5826 100644
--- a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
+++ b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
@@ -6861,6 +6861,76 @@ await TestInClassAsync(markup,
                 Documentation("Summary documentation"));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestInheritdocTwoLevels1()
+        {
+            var markup =
+@"
+/// <summary>Summary documentation</summary>
+/// <remarks>Remarks documentation</remarks>
+void M() { }
+
+/// <inheritdoc cref=""M()""/>
+void M(int x) { }
+
+/// <inheritdoc cref=""M(int)""/>
+void $$M(int x, int y) { }";
+
+            await TestInClassAsync(markup,
+                MainDescription("void C.M(int x, int y)"),
+                Documentation("Summary documentation"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestInheritdocTwoLevels2()
+        {
+            var markup =
+@"
+/// <summary>Summary documentation</summary>
+/// <remarks>Remarks documentation</remarks>
+void M() { }
+
+/// <summary><inheritdoc cref=""M()""/></summary>
+void M(int x) { }
+
+/// <summary><inheritdoc cref=""M(int)""/></summary>
+void $$M(int x, int y) { }";
+
+            await TestInClassAsync(markup,
+                MainDescription("void C.M(int x, int y)"),
+                Documentation("Summary documentation"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestInheritdocWithTypeParamRef()
+        {
+            var markup =
+@"
+public class Program
+{
+    public static void Main() => _ = new Test<int>().$$Clone();
+}
+
+public class Test<T> : ICloneable<Test<T>>
+{
+	/// <inheritdoc/>
+	public Test<T> Clone() => new();
+}
+
+/// <summary>A type that has clonable instances.</summary>
+/// <typeparam name=""T"">The type of instances that can be cloned.</typeparam>
+public interface ICloneable<T>
+{
+    /// <summary>Clones a <typeparamref name=""T""/>.</summary>
+    /// <returns>A clone of the <typeparamref name=""T""/>.</returns>
+    public T Clone();
+}";
+
+            await TestInClassAsync(markup,
+                MainDescription("Test<int> Test<int>.Clone()"),
+                Documentation("Clones a Test<T>."));
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
         public async Task TestInheritdocCycle1()
         {
@@ -7304,5 +7374,228 @@ void M2()
 }",
                 MainDescription($"({FeaturesResources.local_variable}) string? x"));
         }
+
+        [WorkItem(53135, "https://github.com/dotnet/roslyn/issues/53135")]
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestDocumentationCData()
+        {
+            var markup =
+@"using I$$ = IGoo;
+/// <summary>
+/// summary for interface IGoo
+/// <code><![CDATA[
+/// List<string> y = null;
+/// ]]></code>
+/// </summary>
+interface IGoo {  }";
+
+            await TestAsync(markup,
+                MainDescription("interface IGoo"),
+                Documentation(@"summary for interface IGoo
+
+List<string> y = null;"));
+        }
+
+        [WorkItem(37503, "https://github.com/dotnet/roslyn/issues/37503")]
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task DoNotNormalizeWhitespaceForCode()
+        {
+            var markup =
+@"using I$$ = IGoo;
+/// <summary>
+/// Normalize    this, and <c>Also        this</c>
+/// <code>
+/// line 1
+/// line     2
+/// </code>
+/// </summary>
+interface IGoo {  }";
+
+            await TestAsync(markup,
+                MainDescription("interface IGoo"),
+                Documentation(@"Normalize this, and Also this
+
+line 1
+line     2"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestStaticAbstract_ImplicitImplementation()
+        {
+            var code = @"
+interface I1
+{
+    /// <summary>Summary text</summary>
+    static abstract void M1();
+}
+
+class C1_1 : I1
+{
+    public static void $$M1() { }
+}
+";
+
+            await TestAsync(
+                code,
+                MainDescription("void C1_1.M1()"),
+                Documentation("Summary text"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestStaticAbstract_ImplicitImplementation_FromReference()
+        {
+            var code = @"
+interface I1
+{
+    /// <summary>Summary text</summary>
+    static abstract void M1();
+}
+
+class C1_1 : I1
+{
+    public static void M1() { }
+}
+
+class R
+{
+    public static void M() { C1_1.$$M1(); }
+}
+";
+
+            await TestAsync(
+                code,
+                MainDescription("void C1_1.M1()"),
+                Documentation("Summary text"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestStaticAbstract_FromTypeParameterReference()
+        {
+            var code = @"
+interface I1
+{
+    /// <summary>Summary text</summary>
+    static abstract void M1();
+}
+
+class R
+{
+    public static void M<T>() where T : I1 { T.$$M1(); }
+}
+";
+
+            await TestAsync(
+                code,
+                MainDescription("void I1.M1()"),
+                Documentation("Summary text"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestStaticAbstract_ExplicitInheritdoc_ImplicitImplementation()
+        {
+            var code = @"
+interface I1
+{
+    /// <summary>Summary text</summary>
+    static abstract void M1();
+}
+
+class C1_1 : I1
+{
+    /// <inheritdoc/>
+    public static void $$M1() { }
+}
+";
+
+            await TestAsync(
+                code,
+                MainDescription("void C1_1.M1()"),
+                Documentation("Summary text"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestStaticAbstract_ExplicitImplementation()
+        {
+            var code = @"
+interface I1
+{
+    /// <summary>Summary text</summary>
+    static abstract void M1();
+}
+
+class C1_1 : I1
+{
+    static void I1.$$M1() { }
+}
+";
+
+            await TestAsync(
+                code,
+                MainDescription("void C1_1.M1()"),
+                Documentation("Summary text"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestStaticAbstract_ExplicitInheritdoc_ExplicitImplementation()
+        {
+            var code = @"
+interface I1
+{
+    /// <summary>Summary text</summary>
+    static abstract void M1();
+}
+
+class C1_1 : I1
+{
+    /// <inheritdoc/>
+    static void I1.$$M1() { }
+}
+";
+
+            await TestAsync(
+                code,
+                MainDescription("void C1_1.M1()"),
+                Documentation("Summary text"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task QuickInfoLambdaReturnType_01()
+        {
+            await TestWithOptionsAsync(
+                Options.Regular.WithLanguageVersion(LanguageVersion.CSharp9),
+@"class Program
+{
+    System.Delegate D = bo$$ol () => true;
+}",
+                MainDescription("struct System.Boolean"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task QuickInfoLambdaReturnType_02()
+        {
+            await TestWithOptionsAsync(
+                Options.Regular.WithLanguageVersion(LanguageVersion.CSharp9),
+@"class A
+{
+    struct B { }
+    System.Delegate D = A.B$$ () => null;
+}",
+                MainDescription("struct A.B"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task QuickInfoLambdaReturnType_03()
+        {
+            await TestWithOptionsAsync(
+                Options.Regular.WithLanguageVersion(LanguageVersion.CSharp9),
+@"class A<T>
+{
+}
+struct B
+{
+    System.Delegate D = A<B$$> () => null;
+}",
+                MainDescription("struct B"));
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/SignatureHelp/InvocationExpressionSignatureHelpProviderTests.cs b/src/EditorFeatures/CSharpTest/SignatureHelp/InvocationExpressionSignatureHelpProviderTests.cs
index 6e676e6379bb9..bdad786acc55d 100644
--- a/src/EditorFeatures/CSharpTest/SignatureHelp/InvocationExpressionSignatureHelpProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/SignatureHelp/InvocationExpressionSignatureHelpProviderTests.cs
@@ -2524,6 +2524,7 @@ void goo()
                 expectedItems.Add(new SignatureHelpTestItem($"void C.M(object o)", currentParameterIndex: 0));
                 expectedItems.Add(new SignatureHelpTestItem($"void C.M<T>(Action<T> arg1, T arg2, bool flag)\r\n\r\n{string.Format(FeaturesResources._0_1, "Proj1", FeaturesResources.Available)}\r\n{string.Format(FeaturesResources._0_1, "Proj2", FeaturesResources.Not_Available)}\r\n\r\n{FeaturesResources.You_can_use_the_navigation_bar_to_switch_contexts}", currentParameterIndex: 0));
             }
+
             await VerifyItemWithReferenceWorkerAsync(markup, expectedItems, hideAdvancedMembers: false);
         }
     }
diff --git a/src/EditorFeatures/CSharpTest/SplitStringLiteral/SplitStringLiteralCommandHandlerTests.cs b/src/EditorFeatures/CSharpTest/SplitStringLiteral/SplitStringLiteralCommandHandlerTests.cs
index 92f503e11e5c5..48b8c995906dd 100644
--- a/src/EditorFeatures/CSharpTest/SplitStringLiteral/SplitStringLiteralCommandHandlerTests.cs
+++ b/src/EditorFeatures/CSharpTest/SplitStringLiteral/SplitStringLiteralCommandHandlerTests.cs
@@ -64,6 +64,7 @@ private static void TestWorker(
             {
                 snapshotSpans.Add(selection.ToSnapshotSpan(originalSnapshot));
             }
+
             view.SetMultiSelection(snapshotSpans);
 
             var undoHistoryRegistry = workspace.GetService<ITextUndoHistoryRegistry>();
diff --git a/src/EditorFeatures/CSharpTest/Wrapping/ParameterWrappingTests.cs b/src/EditorFeatures/CSharpTest/Wrapping/ParameterWrappingTests.cs
index 387a414ac8235..e6f1d1c514d27 100644
--- a/src/EditorFeatures/CSharpTest/Wrapping/ParameterWrappingTests.cs
+++ b/src/EditorFeatures/CSharpTest/Wrapping/ParameterWrappingTests.cs
@@ -6,6 +6,7 @@
 
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.CSharp.Wrapping;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Xunit;
@@ -923,5 +924,41 @@ void Local(C c,
     }
 }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsWrapping)]
+        public async Task TestRecord_Semicolon()
+        {
+            await TestInRegularAndScript1Async(
+"record R([||]int I, string S);",
+@"record R(int I,
+         string S);");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsWrapping)]
+        public async Task TestRecord_Braces()
+        {
+            await TestInRegularAndScript1Async(
+"record R([||]int I, string S) { }",
+@"record R(int I,
+         string S) { }");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsWrapping)]
+        public async Task TestRecordStruct_Semicolon()
+        {
+            await TestInRegularAndScript1Async(
+"record struct R([||]int I, string S);",
+@"record struct R(int I,
+                string S);", new TestParameters(TestOptions.RegularPreview));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsWrapping)]
+        public async Task TestRecordStruct_Braces()
+        {
+            await TestInRegularAndScript1Async(
+"record struct R([||]int I, string S) { }",
+@"record struct R(int I,
+                string S) { }", new TestParameters(TestOptions.RegularPreview));
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest2/Recommendations/AbstractKeywordRecommenderTests.cs b/src/EditorFeatures/CSharpTest2/Recommendations/AbstractKeywordRecommenderTests.cs
index 1687084899b56..67cd2e565fefc 100644
--- a/src/EditorFeatures/CSharpTest2/Recommendations/AbstractKeywordRecommenderTests.cs
+++ b/src/EditorFeatures/CSharpTest2/Recommendations/AbstractKeywordRecommenderTests.cs
@@ -280,10 +280,18 @@ public async Task TestNotAfterSealed()
         public async Task TestNotAfterStatic()
             => await VerifyAbsenceAsync(@"static $$");
 
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedStatic([CombinatorialValues("class", "struct", "record", "record struct", "record class")] string declarationKind)
+        {
+            await VerifyAbsenceAsync(declarationKind + @" C {
+    static $$");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedStatic()
+        public async Task TestAfterNestedStaticInInterface()
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyKeywordAsync(@"interface C {
     static $$");
         }
 
@@ -299,24 +307,27 @@ await VerifyKeywordAsync(
         public async Task TestNotAfterDelegate()
             => await VerifyAbsenceAsync(@"delegate $$");
 
-        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedAbstract()
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedAbstract([CombinatorialValues("class", "struct", "record", "record struct", "record class", "interface")] string declarationKind)
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyAbsenceAsync(declarationKind + @" C {
     abstract $$");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedVirtual()
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedVirtual([CombinatorialValues("class", "struct", "record", "record struct", "record class", "interface")] string declarationKind)
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyAbsenceAsync(declarationKind + @" C {
     virtual $$");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedSealed()
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedSealed([CombinatorialValues("class", "struct", "record", "record struct", "record class", "interface")] string declarationKind)
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyAbsenceAsync(declarationKind + @" C {
     sealed $$");
         }
 
diff --git a/src/EditorFeatures/CSharpTest2/Recommendations/ExplicitKeywordRecommenderTests.cs b/src/EditorFeatures/CSharpTest2/Recommendations/ExplicitKeywordRecommenderTests.cs
index b065e3d8da967..68389be670a4a 100644
--- a/src/EditorFeatures/CSharpTest2/Recommendations/ExplicitKeywordRecommenderTests.cs
+++ b/src/EditorFeatures/CSharpTest2/Recommendations/ExplicitKeywordRecommenderTests.cs
@@ -238,25 +238,113 @@ public async Task TestNotAfterStaticPublic()
             => await VerifyAbsenceAsync(@"static public $$");
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterNestedStaticPublic()
+        public async Task TestAfterNestedStaticPublicInClass()
         {
             await VerifyKeywordAsync(
 @"class C {
     static public $$");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedStaticPublicInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    static public $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedAbstractPublicInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    abstract public $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedStaticAbstractPublicInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    static abstract public $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedAbstractStaticPublicInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    abstract static public $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedStaticAbstractInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    static abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedAbstractStaticInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    abstract static $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedStaticInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    static $$");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestNotAfterPublicStatic()
             => await VerifyAbsenceAsync(@"public static $$");
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterNestedPublicStatic()
+        public async Task TestAfterNestedPublicStaticInClass()
         {
             await VerifyKeywordAsync(
 @"class C {
     public static $$");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedPublicStaticInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    public static $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedPublicAbstractInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    public abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedPublicStaticAbstractInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    public static abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedPublicAbstractStaticInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    public abstract static $$");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestNotAfterInvalidPublic()
             => await VerifyAbsenceAsync(@"virtual public $$");
@@ -313,35 +401,35 @@ await VerifyAbsenceAsync(
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedAbstract()
+        public async Task TestNotAfterNestedAbstractInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     abstract $$");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedVirtual()
+        public async Task TestNotAfterNestedVirtualInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     virtual $$");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedOverride()
+        public async Task TestNotAfterNestedOverrideInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     override $$");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterNestedSealed()
+        public async Task TestNotAfterNestedSealedInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     sealed $$");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedReadOnly()
+        public async Task TestNotAfterNestedReadOnlyInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     readonly $$");
@@ -349,10 +437,59 @@ await VerifyAbsenceAsync(@"class C {
 
         [WorkItem(544102, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544102")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterUnsafeStaticPublic()
+        public async Task TestAfterNestedUnsafeStaticPublicInClass()
         {
             await VerifyKeywordAsync(@"class C {
      unsafe static public $$");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedAbstractInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedVirtualInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    virtual $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedOverrideInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    override $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedSealedInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    sealed $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedReadOnlyInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    readonly $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterUnsafeStaticAbstractInInterface()
+        {
+            await VerifyKeywordAsync(@"interface C {
+     unsafe static abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterExternStaticAbstractInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+     extern static abstract $$");
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest2/Recommendations/ImplicitKeywordRecommenderTests.cs b/src/EditorFeatures/CSharpTest2/Recommendations/ImplicitKeywordRecommenderTests.cs
index dea0b522ee7f3..5967a4a667651 100644
--- a/src/EditorFeatures/CSharpTest2/Recommendations/ImplicitKeywordRecommenderTests.cs
+++ b/src/EditorFeatures/CSharpTest2/Recommendations/ImplicitKeywordRecommenderTests.cs
@@ -238,25 +238,113 @@ public async Task TestNotAfterStaticPublic()
             => await VerifyAbsenceAsync(@"static public $$");
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterNestedStaticPublic()
+        public async Task TestAfterNestedStaticPublicInClass()
         {
             await VerifyKeywordAsync(
 @"class C {
     static public $$");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedStaticPublicInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    static public $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedAbstractPublicInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    abstract public $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedStaticAbstractPublicInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    static abstract public $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedAbstractStaticPublicInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    abstract static public $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedStaticAbstractInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    static abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedAbstractStaticInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    abstract static $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedStaticInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    static $$");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestNotAfterPublicStatic()
             => await VerifyAbsenceAsync(@"public static $$");
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterNestedPublicStatic()
+        public async Task TestAfterNestedPublicStaticInClass()
         {
             await VerifyKeywordAsync(
 @"class C {
     public static $$");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedPublicStaticInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    public static $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedPublicAbstractInInterface()
+        {
+            await VerifyAbsenceAsync(
+@"interface C {
+    public abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedPublicStaticAbstractInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    public static abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterNestedPublicAbstractStaticInInterface()
+        {
+            await VerifyKeywordAsync(
+@"interface C {
+    public abstract static $$");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestNotAfterInvalidPublic()
             => await VerifyAbsenceAsync(@"virtual public $$");
@@ -313,35 +401,35 @@ await VerifyAbsenceAsync(
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedAbstract()
+        public async Task TestNotAfterNestedAbstractInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     abstract $$");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedVirtual()
+        public async Task TestNotAfterNestedVirtualInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     virtual $$");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedOverride()
+        public async Task TestNotAfterNestedOverrideInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     override $$");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterNestedSealed()
+        public async Task TestNotAfterNestedSealedInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     sealed $$");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedReadOnly()
+        public async Task TestNotAfterNestedReadOnlyInClass()
         {
             await VerifyAbsenceAsync(@"class C {
     readonly $$");
@@ -349,10 +437,59 @@ await VerifyAbsenceAsync(@"class C {
 
         [WorkItem(544103, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544103")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterUnsafeStaticPublic()
+        public async Task TestAfterNestedUnsafeStaticPublicInClass()
         {
             await VerifyKeywordAsync(@"class C {
      unsafe static public $$");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedAbstractInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedVirtualInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    virtual $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedOverrideInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    override $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedSealedInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    sealed $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterNestedReadOnlyInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+    readonly $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterUnsafeStaticAbstractInInterface()
+        {
+            await VerifyKeywordAsync(@"interface C {
+     unsafe static abstract $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterExternStaticAbstractInInterface()
+        {
+            await VerifyAbsenceAsync(@"interface C {
+     extern static abstract $$");
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest2/Recommendations/RecordKeywordRecommenderTests.cs b/src/EditorFeatures/CSharpTest2/Recommendations/RecordKeywordRecommenderTests.cs
index bcf70ccee66f2..be370faab5655 100644
--- a/src/EditorFeatures/CSharpTest2/Recommendations/RecordKeywordRecommenderTests.cs
+++ b/src/EditorFeatures/CSharpTest2/Recommendations/RecordKeywordRecommenderTests.cs
@@ -435,5 +435,12 @@ await VerifyKeywordAsync(
 @"class C {
     new $$");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterReadonly()
+        {
+            // readonly record struct is allowed.
+            await VerifyKeywordAsync("readonly $$");
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest2/Recommendations/SealedKeywordRecommenderTests.cs b/src/EditorFeatures/CSharpTest2/Recommendations/SealedKeywordRecommenderTests.cs
index d92a732f94bb6..ec808ebd39fd3 100644
--- a/src/EditorFeatures/CSharpTest2/Recommendations/SealedKeywordRecommenderTests.cs
+++ b/src/EditorFeatures/CSharpTest2/Recommendations/SealedKeywordRecommenderTests.cs
@@ -280,10 +280,18 @@ public async Task TestNotAfterSealed()
         public async Task TestNotAfterStatic()
             => await VerifyAbsenceAsync(@"static $$");
 
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedStatic([CombinatorialValues("class", "struct", "record", "record struct", "record class")] string declarationKind)
+        {
+            await VerifyAbsenceAsync(declarationKind + @" C {
+    static $$");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedStatic()
+        public async Task TestAfterNestedStaticInInterface()
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyKeywordAsync(@"interface C {
     static $$");
         }
 
@@ -299,17 +307,19 @@ await VerifyKeywordAsync(
         public async Task TestNotAfterDelegate()
             => await VerifyAbsenceAsync(@"delegate $$");
 
-        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedAbstract()
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedAbstract([CombinatorialValues("class", "struct", "record", "record struct", "record class", "interface")] string declarationKind)
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyAbsenceAsync(declarationKind + @" C {
     abstract $$");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedVirtual()
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedVirtual([CombinatorialValues("class", "struct", "record", "record struct", "record class", "interface")] string declarationKind)
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyAbsenceAsync(declarationKind + @" C {
     virtual $$");
         }
 
@@ -321,10 +331,11 @@ await VerifyKeywordAsync(
     override $$");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedSealed()
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedSealed([CombinatorialValues("class", "struct", "record", "record struct", "record class", "interface")] string declarationKind)
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyAbsenceAsync(declarationKind + @" C {
     sealed $$");
         }
 
diff --git a/src/EditorFeatures/CSharpTest2/Recommendations/StaticKeywordRecommenderTests.cs b/src/EditorFeatures/CSharpTest2/Recommendations/StaticKeywordRecommenderTests.cs
index 3c5b7e85e4f69..31603af3711b2 100644
--- a/src/EditorFeatures/CSharpTest2/Recommendations/StaticKeywordRecommenderTests.cs
+++ b/src/EditorFeatures/CSharpTest2/Recommendations/StaticKeywordRecommenderTests.cs
@@ -335,31 +335,49 @@ public async Task TestNotBetweenGlobalUsings_02()
             //await VerifyWorkerAsync(source, absent: true, Options.Script);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedAbstract()
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedAbstract([CombinatorialValues("class", "struct", "record", "record struct", "record class")] string declarationKind)
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyAbsenceAsync(declarationKind + @" C {
     abstract $$");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedVirtual()
+        public async Task TestAfterNestedAbstractInInterface()
+        {
+            await VerifyKeywordAsync(@"interface C {
+    abstract $$");
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedVirtual([CombinatorialValues("class", "struct", "record", "record struct", "record class", "interface")] string declarationKind)
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyAbsenceAsync(declarationKind + @" C {
     virtual $$");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedOverride()
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedOverride([CombinatorialValues("class", "struct", "record", "record struct", "record class", "interface")] string declarationKind)
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyAbsenceAsync(declarationKind + @" C {
     override $$");
         }
 
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [CombinatorialData]
+        public async Task TestNotAfterNestedSealed([CombinatorialValues("class", "struct", "record", "record struct", "record class")] string declarationKind)
+        {
+            await VerifyAbsenceAsync(declarationKind + @" C {
+    sealed $$");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestNotAfterNestedSealed()
+        public async Task TestAfterNestedSealedInInterface()
         {
-            await VerifyAbsenceAsync(@"class C {
+            await VerifyKeywordAsync(@"interface C {
     sealed $$");
         }
 
diff --git a/src/EditorFeatures/Core.Cocoa/NavigationCommandHandlers/FindReferencesOfOverloadsCommandHandler.cs b/src/EditorFeatures/Core.Cocoa/NavigationCommandHandlers/FindReferencesOfOverloadsCommandHandler.cs
index 433908df46f91..5006710ae5adb 100644
--- a/src/EditorFeatures/Core.Cocoa/NavigationCommandHandlers/FindReferencesOfOverloadsCommandHandler.cs
+++ b/src/EditorFeatures/Core.Cocoa/NavigationCommandHandlers/FindReferencesOfOverloadsCommandHandler.cs
@@ -81,6 +81,7 @@ private static async Task<ISymbol[]> GatherSymbolsAsync(ISymbol symbol, Microsof
             {
                 result[i++] = item;
             }
+
             return result;
         }
 
diff --git a/src/EditorFeatures/Core.Cocoa/Preview/PreviewPane.cs b/src/EditorFeatures/Core.Cocoa/Preview/PreviewPane.cs
index 57d6587bb3621..ef6ac2fa67878 100644
--- a/src/EditorFeatures/Core.Cocoa/Preview/PreviewPane.cs
+++ b/src/EditorFeatures/Core.Cocoa/Preview/PreviewPane.cs
@@ -143,6 +143,7 @@ protected override void Dispose(bool disposing)
                 _differenceViewerPreview?.Dispose();
                 _differenceViewerPreview = null;
             }
+
             base.Dispose(disposing);
         }
     }
diff --git a/src/EditorFeatures/Core.Wpf/Adornments/AbstractAdornmentManagerProvider.cs b/src/EditorFeatures/Core.Wpf/Adornments/AbstractAdornmentManagerProvider.cs
index b14b99ceca4df..c6265c6c55bc8 100644
--- a/src/EditorFeatures/Core.Wpf/Adornments/AbstractAdornmentManagerProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/Adornments/AbstractAdornmentManagerProvider.cs
@@ -18,23 +18,25 @@ internal abstract class AbstractAdornmentManagerProvider<TTag> :
         IWpfTextViewCreationListener
         where TTag : GraphicsTag
     {
-        private readonly IThreadingContext _threadingContext;
-        private readonly IViewTagAggregatorFactoryService _tagAggregatorFactoryService;
-        private readonly IAsynchronousOperationListener _asyncListener;
+        protected readonly IThreadingContext ThreadingContext;
+        protected readonly IViewTagAggregatorFactoryService TagAggregatorFactoryService;
+        protected readonly IAsynchronousOperationListener AsyncListener;
 
         protected AbstractAdornmentManagerProvider(
             IThreadingContext threadingContext,
             IViewTagAggregatorFactoryService tagAggregatorFactoryService,
             IAsynchronousOperationListenerProvider listenerProvider)
         {
-            _threadingContext = threadingContext;
-            _tagAggregatorFactoryService = tagAggregatorFactoryService;
-            _asyncListener = listenerProvider.GetListener(this.FeatureAttributeName);
+            ThreadingContext = threadingContext;
+            TagAggregatorFactoryService = tagAggregatorFactoryService;
+            AsyncListener = listenerProvider.GetListener(this.FeatureAttributeName);
         }
 
         protected abstract string FeatureAttributeName { get; }
         protected abstract string AdornmentLayerName { get; }
 
+        protected abstract void CreateAdornmentManager(IWpfTextView textView);
+
         public void TextViewCreated(IWpfTextView textView)
         {
             if (textView == null)
@@ -47,8 +49,7 @@ public void TextViewCreated(IWpfTextView textView)
                 return;
             }
 
-            // the manager keeps itself alive by listening to text view events.
-            AdornmentManager<TTag>.Create(_threadingContext, textView, _tagAggregatorFactoryService, _asyncListener, AdornmentLayerName);
+            CreateAdornmentManager(textView);
         }
     }
 }
diff --git a/src/EditorFeatures/Core.Wpf/Adornments/AdornmentManager.cs b/src/EditorFeatures/Core.Wpf/Adornments/AdornmentManager.cs
index 1ffa5890307cf..b9f6b997a3848 100644
--- a/src/EditorFeatures/Core.Wpf/Adornments/AdornmentManager.cs
+++ b/src/EditorFeatures/Core.Wpf/Adornments/AdornmentManager.cs
@@ -22,42 +22,36 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.Adornments
     /// <summary>
     /// UI manager for graphic overlay tags. These tags will simply paint something related to the text.
     /// </summary>
-    internal class AdornmentManager<T> where T : GraphicsTag
+    internal abstract class AdornmentManager<T> where T : GraphicsTag
     {
         private readonly object _invalidatedSpansLock = new object();
 
         private readonly IThreadingContext _threadingContext;
 
-        /// <summary>View that created us.</summary>
-        private readonly IWpfTextView _textView;
-
-        /// <summary>Layer where we draw adornments.</summary>
-        private readonly IAdornmentLayer _adornmentLayer;
-
-        /// <summary>Aggregator that tells us where to draw.</summary>
-        private readonly ITagAggregator<T> _tagAggregator;
-
         /// <summary>Notification system about operations we do</summary>
         private readonly IAsynchronousOperationListener _asyncListener;
 
         /// <summary>Spans that are invalidated, and need to be removed from the layer..</summary>
         private List<IMappingSpan> _invalidatedSpans;
 
-        public static AdornmentManager<T> Create(
-            IThreadingContext threadingContext,
-            IWpfTextView textView,
-            IViewTagAggregatorFactoryService aggregatorService,
-            IAsynchronousOperationListener asyncListener,
-            string adornmentLayerName)
-        {
-            Contract.ThrowIfNull(threadingContext);
-            Contract.ThrowIfNull(textView);
-            Contract.ThrowIfNull(aggregatorService);
-            Contract.ThrowIfNull(adornmentLayerName);
-            Contract.ThrowIfNull(asyncListener);
+        /// <summary>View that created us.</summary>
+        protected IWpfTextView TextView { get; }
 
-            return new AdornmentManager<T>(threadingContext, textView, aggregatorService, asyncListener, adornmentLayerName);
-        }
+        /// <summary>Layer where we draw adornments.</summary>
+        protected IAdornmentLayer AdornmentLayer { get; }
+
+        /// <summary>Aggregator that tells us where to draw.</summary>
+        protected ITagAggregator<T> TagAggregator { get; }
+
+        /// <summary>
+        /// MUST BE CALLED ON UI THREAD!!!!   This method touches WPF.
+        /// 
+        /// This is where we apply visuals to the text. 
+        /// 
+        /// It happens when another region of the view becomes visible or there is a change in tags.
+        /// For us the end result is the same - get tags from tagger and update visuals correspondingly.
+        /// </summary>        
+        protected abstract void UpdateSpans_CallOnlyOnUIThread(NormalizedSnapshotSpanCollection changedSpanCollection, bool removeOldTags);
 
         internal AdornmentManager(
             IThreadingContext threadingContext,
@@ -73,8 +67,8 @@ internal AdornmentManager(
             Contract.ThrowIfNull(asyncListener);
 
             _threadingContext = threadingContext;
-            _textView = textView;
-            _adornmentLayer = textView.GetAdornmentLayer(adornmentLayerName);
+            TextView = textView;
+            AdornmentLayer = textView.GetAdornmentLayer(adornmentLayerName);
             textView.LayoutChanged += OnLayoutChanged;
             _asyncListener = asyncListener;
 
@@ -82,20 +76,20 @@ internal AdornmentManager(
             Contract.ThrowIfFalse(textView.VisualElement.Dispatcher.CheckAccess());
             textView.Closed += OnTextViewClosed;
 
-            _tagAggregator = tagAggregatorFactoryService.CreateTagAggregator<T>(textView);
+            TagAggregator = tagAggregatorFactoryService.CreateTagAggregator<T>(textView);
 
-            _tagAggregator.TagsChanged += OnTagsChanged;
+            TagAggregator.TagsChanged += OnTagsChanged;
         }
 
         private void OnTextViewClosed(object sender, System.EventArgs e)
         {
             // release the aggregator
-            _tagAggregator.TagsChanged -= OnTagsChanged;
-            _tagAggregator.Dispose();
+            TagAggregator.TagsChanged -= OnTagsChanged;
+            TagAggregator.Dispose();
 
             // unhook from view
-            _textView.Closed -= OnTextViewClosed;
-            _textView.LayoutChanged -= OnLayoutChanged;
+            TextView.Closed -= OnTextViewClosed;
+            TextView.LayoutChanged -= OnLayoutChanged;
 
             // At this point, this object should be available for garbage collection.
         }
@@ -110,10 +104,10 @@ private void OnLayoutChanged(object sender, TextViewLayoutChangedEventArgs e)
             using (_asyncListener.BeginAsyncOperation(GetType() + ".OnLayoutChanged"))
             {
                 // Make sure we're on the UI thread.
-                Contract.ThrowIfFalse(_textView.VisualElement.Dispatcher.CheckAccess());
+                Contract.ThrowIfFalse(TextView.VisualElement.Dispatcher.CheckAccess());
 
                 var reformattedSpans = e.NewOrReformattedSpans;
-                var viewSnapshot = _textView.TextSnapshot;
+                var viewSnapshot = TextView.TextSnapshot;
 
                 // No need to remove tags as these spans are reformatted anyways.
                 UpdateSpans_CallOnlyOnUIThread(reformattedSpans, removeOldTags: false);
@@ -182,7 +176,7 @@ private void OnTagsChanged(object sender, TagsChangedEventArgs e)
                 if (needToScheduleUpdate)
                 {
                     // schedule an update
-                    _threadingContext.JoinableTaskFactory.WithPriority(_textView.VisualElement.Dispatcher, DispatcherPriority.Render).RunAsync(async () =>
+                    _threadingContext.JoinableTaskFactory.WithPriority(TextView.VisualElement.Dispatcher, DispatcherPriority.Render).RunAsync(async () =>
                     {
                         using (_asyncListener.BeginAsyncOperation(GetType() + ".OnTagsChanged.2"))
                         {
@@ -205,7 +199,7 @@ private void UpdateInvalidSpans()
             using (Logger.LogBlock(FunctionId.Tagger_AdornmentManager_UpdateInvalidSpans, CancellationToken.None))
             {
                 // this method should only run on UI thread as we do WPF here.
-                Contract.ThrowIfFalse(_textView.VisualElement.Dispatcher.CheckAccess());
+                Contract.ThrowIfFalse(TextView.VisualElement.Dispatcher.CheckAccess());
 
                 List<IMappingSpan> invalidated;
                 lock (_invalidatedSpansLock)
@@ -214,118 +208,25 @@ private void UpdateInvalidSpans()
                     _invalidatedSpans = null;
                 }
 
-                if (_textView.IsClosed)
+                if (TextView.IsClosed)
                 {
                     return; // already closed
                 }
 
                 if (invalidated != null)
                 {
-                    var viewSnapshot = _textView.TextSnapshot;
+                    var viewSnapshot = TextView.TextSnapshot;
                     var invalidatedNormalized = TranslateAndNormalize(invalidated, viewSnapshot);
                     UpdateSpans_CallOnlyOnUIThread(invalidatedNormalized, removeOldTags: true);
                 }
             }
         }
 
-        /// <summary>
-        /// MUST BE CALLED ON UI THREAD!!!!   This method touches WPF.
-        /// 
-        /// This is where we apply visuals to the text. 
-        /// 
-        /// It happens when another region of the view becomes visible or there is a change in tags.
-        /// For us the end result is the same - get tags from tagger and update visuals correspondingly.
-        /// </summary>        
-        private void UpdateSpans_CallOnlyOnUIThread(NormalizedSnapshotSpanCollection changedSpanCollection, bool removeOldTags)
-        {
-            Contract.ThrowIfNull(changedSpanCollection);
-
-            // this method should only run on UI thread as we do WPF here.
-            Contract.ThrowIfFalse(_textView.VisualElement.Dispatcher.CheckAccess());
-
-            var viewSnapshot = _textView.TextSnapshot;
-            var visualSnapshot = _textView.VisualSnapshot;
-
-            var viewLines = _textView.TextViewLines;
-            if (viewLines == null || viewLines.Count == 0)
-            {
-                return; // nothing to draw on
-            }
-
-            // removing is a separate pass from adding so that new stuff is not removed.
-            if (removeOldTags)
-            {
-                foreach (var changedSpan in changedSpanCollection)
-                {
-                    // is there any effect on the view?
-                    if (viewLines.IntersectsBufferSpan(changedSpan))
-                    {
-                        _adornmentLayer.RemoveAdornmentsByVisualSpan(changedSpan);
-                    }
-                }
-            }
-
-            foreach (var changedSpan in changedSpanCollection)
-            {
-                // is there any effect on the view?
-                if (!viewLines.IntersectsBufferSpan(changedSpan))
-                {
-                    continue;
-                }
-
-                var tagSpans = _tagAggregator.GetTags(changedSpan);
-                foreach (var tagMappingSpan in tagSpans)
-                {
-                    // We don't want to draw line separators if they would intersect a collapsed outlining
-                    // region.  So we test if we can map the start of the line separator up to our visual 
-                    // snapshot. If we can't, then we just skip it.
-                    var point = tagMappingSpan.Span.Start.GetPoint(changedSpan.Snapshot, PositionAffinity.Predecessor);
-                    if (point == null)
-                    {
-                        continue;
-                    }
-
-                    var mappedPoint = _textView.BufferGraph.MapUpToSnapshot(
-                        point.Value, PointTrackingMode.Negative, PositionAffinity.Predecessor, _textView.VisualSnapshot);
-                    if (mappedPoint == null)
-                    {
-                        continue;
-                    }
-
-                    if (!TryMapToSingleSnapshotSpan(tagMappingSpan.Span, viewSnapshot, out var span))
-                    {
-                        continue;
-                    }
-
-                    if (!viewLines.IntersectsBufferSpan(span))
-                    {
-                        // span is outside of the view so we will not get geometry for it, but may 
-                        // spent a lot of time trying.
-                        continue;
-                    }
-
-                    // add the visual to the adornment layer.
-                    var geometry = viewLines.GetMarkerGeometry(span);
-                    if (geometry != null)
-                    {
-                        var tag = tagMappingSpan.Tag;
-                        var graphicsResult = tag.GetGraphics(_textView, geometry);
-                        _adornmentLayer.AddAdornment(
-                            behavior: AdornmentPositioningBehavior.TextRelative,
-                            visualSpan: span,
-                            tag: tag,
-                            adornment: graphicsResult.VisualElement,
-                            removedCallback: delegate { graphicsResult.Dispose(); });
-                    }
-                }
-            }
-        }
-
         // Map the mapping span to the visual snapshot. note that as a result of projection
         // topology, originally single span may be mapped into several spans. Visual adornments do
         // not make much sense on disjoint spans. We will not decorate spans that could not make it
         // in one piece.
-        private static bool TryMapToSingleSnapshotSpan(IMappingSpan mappingSpan, ITextSnapshot viewSnapshot, out SnapshotSpan span)
+        protected static bool TryMapToSingleSnapshotSpan(IMappingSpan mappingSpan, ITextSnapshot viewSnapshot, out SnapshotSpan span)
         {
             // IMappingSpan.GetSpans is a surprisingly expensive function that allocates multiple
             // lists and collection if the view buffer is same as anchor we could just map the
diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index 48fd5dff6c9a1..ea6d47700ed15 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -14,6 +14,7 @@
 using System.Windows.Input;
 using System.Windows.Media;
 using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.InlineHints;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -94,8 +95,8 @@ public async Task<IReadOnlyCollection<object>> CreateDescriptionAsync(Cancellati
                 var taggedText = await _hint.GetDescriptionAsync(document, cancellationToken).ConfigureAwait(false);
                 if (!taggedText.IsDefaultOrEmpty)
                 {
-                    return Implementation.IntelliSense.Helpers.BuildInteractiveTextElements(
-                        taggedText, document, _threadingContext, _streamingPresenter);
+                    var context = new IntellisenseQuickInfoBuilderContext(document, _threadingContext, _streamingPresenter);
+                    return Implementation.IntelliSense.Helpers.BuildInteractiveTextElements(taggedText, context);
                 }
             }
 
diff --git a/src/EditorFeatures/Core.Wpf/Interactive/InteractivePasteCommandHandler.cs b/src/EditorFeatures/Core.Wpf/Interactive/InteractivePasteCommandHandler.cs
index cd325079749bc..48dbd5836eb5e 100644
--- a/src/EditorFeatures/Core.Wpf/Interactive/InteractivePasteCommandHandler.cs
+++ b/src/EditorFeatures/Core.Wpf/Interactive/InteractivePasteCommandHandler.cs
@@ -131,6 +131,7 @@ private void PasteInteractiveFormat(ITextView textView)
             {
                 editorOperations.InsertText(text);
             }
+
             editorOperations.AddAfterTextBufferChangePrimitive();
             transaction.Complete();
         }
@@ -147,6 +148,7 @@ private static bool HasNonWhiteSpaceCharacter(ITextSnapshotLine line)
                     return true;
                 }
             }
+
             return false;
         }
 
diff --git a/src/EditorFeatures/Core.Wpf/LineSeparators/LineSeparatorAdornmentManager.cs b/src/EditorFeatures/Core.Wpf/LineSeparators/LineSeparatorAdornmentManager.cs
new file mode 100644
index 0000000000000..772406ebfbf07
--- /dev/null
+++ b/src/EditorFeatures/Core.Wpf/LineSeparators/LineSeparatorAdornmentManager.cs
@@ -0,0 +1,117 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis.Editor.Implementation.Adornments;
+using Microsoft.CodeAnalysis.Editor.Implementation.LineSeparators;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Tagging;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.LineSeparators
+{
+    internal class LineSeparatorAdornmentManager : AdornmentManager<LineSeparatorTag>
+    {
+        public LineSeparatorAdornmentManager(IThreadingContext threadingContext, IWpfTextView textView,
+            IViewTagAggregatorFactoryService tagAggregatorFactoryService, IAsynchronousOperationListener asyncListener, string adornmentLayerName)
+            : base(threadingContext, textView, tagAggregatorFactoryService, asyncListener, adornmentLayerName)
+        {
+        }
+
+        /// <summary>
+        /// MUST BE CALLED ON UI THREAD!!!!   This method touches WPF.
+        /// 
+        /// This is where we apply visuals to the text. 
+        /// 
+        /// It happens when another region of the view becomes visible or there is a change in tags.
+        /// For us the end result is the same - get tags from tagger and update visuals correspondingly.
+        /// </summary>        
+        protected override void UpdateSpans_CallOnlyOnUIThread(NormalizedSnapshotSpanCollection changedSpanCollection, bool removeOldTags)
+        {
+            Contract.ThrowIfNull(changedSpanCollection);
+
+            // this method should only run on UI thread as we do WPF here.
+            Contract.ThrowIfFalse(TextView.VisualElement.Dispatcher.CheckAccess());
+
+            var viewSnapshot = TextView.TextSnapshot;
+            var visualSnapshot = TextView.VisualSnapshot;
+
+            var viewLines = TextView.TextViewLines;
+            if (viewLines == null || viewLines.Count == 0)
+            {
+                return; // nothing to draw on
+            }
+
+            // removing is a separate pass from adding so that new stuff is not removed.
+            if (removeOldTags)
+            {
+                foreach (var changedSpan in changedSpanCollection)
+                {
+                    // is there any effect on the view?
+                    if (viewLines.IntersectsBufferSpan(changedSpan))
+                    {
+                        AdornmentLayer.RemoveAdornmentsByVisualSpan(changedSpan);
+                    }
+                }
+            }
+
+            foreach (var changedSpan in changedSpanCollection)
+            {
+                // is there any effect on the view?
+                if (!viewLines.IntersectsBufferSpan(changedSpan))
+                {
+                    continue;
+                }
+
+                var tagSpans = TagAggregator.GetTags(changedSpan);
+                foreach (var tagMappingSpan in tagSpans)
+                {
+                    // We don't want to draw line separators if they would intersect a collapsed outlining
+                    // region.  So we test if we can map the start of the line separator up to our visual 
+                    // snapshot. If we can't, then we just skip it.
+                    var point = tagMappingSpan.Span.Start.GetPoint(changedSpan.Snapshot, PositionAffinity.Predecessor);
+                    if (point == null)
+                    {
+                        continue;
+                    }
+
+                    var mappedPoint = TextView.BufferGraph.MapUpToSnapshot(
+                        point.Value, PointTrackingMode.Negative, PositionAffinity.Predecessor, TextView.VisualSnapshot);
+                    if (mappedPoint == null)
+                    {
+                        continue;
+                    }
+
+                    if (!TryMapToSingleSnapshotSpan(tagMappingSpan.Span, viewSnapshot, out var span))
+                    {
+                        continue;
+                    }
+
+                    if (!viewLines.IntersectsBufferSpan(span))
+                    {
+                        // span is outside of the view so we will not get geometry for it, but may 
+                        // spent a lot of time trying.
+                        continue;
+                    }
+
+                    // add the visual to the adornment layer.
+                    var geometry = viewLines.GetMarkerGeometry(span);
+                    if (geometry != null)
+                    {
+                        var tag = tagMappingSpan.Tag;
+                        var graphicsResult = tag.GetGraphics(TextView, geometry);
+                        AdornmentLayer.AddAdornment(
+                            behavior: AdornmentPositioningBehavior.TextRelative,
+                            visualSpan: span,
+                            tag: tag,
+                            adornment: graphicsResult.VisualElement,
+                            removedCallback: delegate { graphicsResult.Dispose(); });
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/EditorFeatures/Core.Wpf/LineSeparators/LineSeparatorAdornmentManagerProvider.cs b/src/EditorFeatures/Core.Wpf/LineSeparators/LineSeparatorAdornmentManagerProvider.cs
index 04596b37595cf..c1852a17a3751 100644
--- a/src/EditorFeatures/Core.Wpf/LineSeparators/LineSeparatorAdornmentManagerProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/LineSeparators/LineSeparatorAdornmentManagerProvider.cs
@@ -7,6 +7,9 @@
 using System;
 using System.ComponentModel.Composition;
 using Microsoft.CodeAnalysis.Editor.Implementation.Adornments;
+using Microsoft.CodeAnalysis.Editor.LineSeparators;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
+using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
@@ -49,5 +52,11 @@ public LineSeparatorAdornmentManagerProvider(
 
         protected override string FeatureAttributeName => FeatureAttribute.LineSeparators;
         protected override string AdornmentLayerName => LayerName;
+
+        protected override void CreateAdornmentManager(IWpfTextView textView)
+        {
+            // the manager keeps itself alive by listening to text view events.
+            _ = new LineSeparatorAdornmentManager(ThreadingContext, textView, TagAggregatorFactoryService, AsyncListener, AdornmentLayerName);
+        }
     }
 }
diff --git a/src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemDisplay.cs b/src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemDisplay.cs
index 739189b0e9308..77466cd692963 100644
--- a/src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemDisplay.cs
+++ b/src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemDisplay.cs
@@ -53,15 +53,7 @@ private ReadOnlyCollection<DescriptionItem> CreateDescriptionItems()
             }
 
             var sourceText = document.GetTextSynchronously(CancellationToken.None);
-            var item = _searchResult.NavigableItem;
-            var spanStart = item.SourceSpan.Start;
-            if (item.IsStale && spanStart > sourceText.Length)
-            {
-                // in the case of a stale item, the span may be out of bounds of the document. Cap
-                // us to the end of the document as that's where we're going to navigate the user
-                // to.
-                spanStart = sourceText.Length;
-            }
+            var span = NavigateToUtilities.GetBoundedSpan(_searchResult.NavigableItem, sourceText);
 
             var items = new List<DescriptionItem>
                     {
@@ -79,7 +71,7 @@ private ReadOnlyCollection<DescriptionItem> CreateDescriptionItems()
                             new ReadOnlyCollection<DescriptionRun>(
                                 new[] { new DescriptionRun("Line:", bold: true) }),
                             new ReadOnlyCollection<DescriptionRun>(
-                                new[] { new DescriptionRun((sourceText.Lines.IndexOf(spanStart) + 1).ToString()) }))
+                                new[] { new DescriptionRun((sourceText.Lines.IndexOf(span.Start) + 1).ToString()) }))
                     };
 
             var summary = _searchResult.Summary;
diff --git a/src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemProvider.cs b/src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemProvider.cs
index 7e11f5c6f471e..fbf3a3b77e44c 100644
--- a/src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/NavigateTo/NavigateToItemProvider.cs
@@ -41,22 +41,7 @@ public NavigateToItemProvider(
         ISet<string> INavigateToItemProvider2.KindsProvided => KindsProvided;
 
         public ImmutableHashSet<string> KindsProvided
-        {
-            get
-            {
-                var result = ImmutableHashSet.Create<string>(StringComparer.Ordinal);
-                foreach (var project in _workspace.CurrentSolution.Projects)
-                {
-                    var navigateToSearchService = project.GetLanguageService<INavigateToSearchService>();
-                    if (navigateToSearchService != null)
-                    {
-                        result = result.Union(navigateToSearchService.KindsProvided);
-                    }
-                }
-
-                return result;
-            }
-        }
+            => NavigateToUtilities.GetKindsProvided(_workspace.CurrentSolution);
 
         public bool CanFilter
         {
diff --git a/src/EditorFeatures/Core.Wpf/SignatureHelp/Controller.Session_ComputeModel.cs b/src/EditorFeatures/Core.Wpf/SignatureHelp/Controller.Session_ComputeModel.cs
index 8dd3316a1bfd4..13e36727a41c0 100644
--- a/src/EditorFeatures/Core.Wpf/SignatureHelp/Controller.Session_ComputeModel.cs
+++ b/src/EditorFeatures/Core.Wpf/SignatureHelp/Controller.Session_ComputeModel.cs
@@ -146,6 +146,7 @@ private static SignatureHelpItem GetSelectedItem(Model currentModel, SignatureHe
                         return userSelectedItem;
                     }
                 }
+
                 userSelected = false;
 
                 // If the provider specified a selected item, then pick that one.
diff --git a/src/EditorFeatures/Core/EditorConfigSettings/Aggregator/SettingsAggregator.cs b/src/EditorFeatures/Core/EditorConfigSettings/Aggregator/SettingsAggregator.cs
index 144b853d9abd9..99cdba9265e4d 100644
--- a/src/EditorFeatures/Core/EditorConfigSettings/Aggregator/SettingsAggregator.cs
+++ b/src/EditorFeatures/Core/EditorConfigSettings/Aggregator/SettingsAggregator.cs
@@ -79,6 +79,7 @@ private static ISettingsProviderFactory<T> GetOptionsProviderFactory<T>(Workspac
             {
                 TryAddProviderForLanguage(LanguageNames.CSharp, workspace, providers);
             }
+
             if (supportsVisualBasic)
             {
                 TryAddProviderForLanguage(LanguageNames.VisualBasic, workspace, providers);
diff --git a/src/EditorFeatures/Core/EditorConfigSettings/Data/CodeStyle/CodeStyleSetting.EnumCodeStyleSettingBase.cs b/src/EditorFeatures/Core/EditorConfigSettings/Data/CodeStyle/CodeStyleSetting.EnumCodeStyleSettingBase.cs
index 8856236da98cc..c4a4abf69d317 100644
--- a/src/EditorFeatures/Core/EditorConfigSettings/Data/CodeStyle/CodeStyleSetting.EnumCodeStyleSettingBase.cs
+++ b/src/EditorFeatures/Core/EditorConfigSettings/Data/CodeStyle/CodeStyleSetting.EnumCodeStyleSettingBase.cs
@@ -29,6 +29,7 @@ public EnumCodeStyleSettingBase(string description,
                 {
                     throw new InvalidOperationException("Values and descriptions must have matching number of elements");
                 }
+
                 _enumValues = enumValues;
                 _valueDescriptions = valueDescriptions;
                 Category = category;
diff --git a/src/EditorFeatures/Core/EditorConfigSettings/Extensions/SolutionExtensions.cs b/src/EditorFeatures/Core/EditorConfigSettings/Extensions/SolutionExtensions.cs
index fe06a29a6b5c8..46418543677ce 100644
--- a/src/EditorFeatures/Core/EditorConfigSettings/Extensions/SolutionExtensions.cs
+++ b/src/EditorFeatures/Core/EditorConfigSettings/Extensions/SolutionExtensions.cs
@@ -49,6 +49,7 @@ static bool ContainsPath(DirectoryInfo givenPath, DirectoryInfo projectPath)
                     {
                         return true;
                     }
+
                     projectPath = projectPath.Parent;
                 }
 
diff --git a/src/EditorFeatures/Core/Extensibility/Commands/PredefinedCommandHandlerNames.cs b/src/EditorFeatures/Core/Extensibility/Commands/PredefinedCommandHandlerNames.cs
index 545e53524b7d7..531132d451939 100644
--- a/src/EditorFeatures/Core/Extensibility/Commands/PredefinedCommandHandlerNames.cs
+++ b/src/EditorFeatures/Core/Extensibility/Commands/PredefinedCommandHandlerNames.cs
@@ -178,5 +178,10 @@ internal static class PredefinedCommandHandlerNames
         /// Command handler name for Edit and Continue file save handler.
         /// </summary>
         public const string EditAndContinueFileSave = "Edit and Continue Save File Handler";
+
+        /// <summary>
+        /// Command handler name for showing the Value Tracking tool window.
+        /// </summary>
+        public const string ShowValueTracking = "Show Value Tracking";
     }
 }
diff --git a/src/EditorFeatures/Core/Extensibility/NavigationBar/INavigationBarController.cs b/src/EditorFeatures/Core/Extensibility/NavigationBar/INavigationBarController.cs
deleted file mode 100644
index 99ef6d783a404..0000000000000
--- a/src/EditorFeatures/Core/Extensibility/NavigationBar/INavigationBarController.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-namespace Microsoft.CodeAnalysis.Editor
-{
-    internal interface INavigationBarController
-    {
-        void Disconnect();
-
-        void SetWorkspace(Workspace? newWorkspace);
-    }
-}
diff --git a/src/EditorFeatures/Core/Extensibility/NavigationBar/INavigationBarControllerFactoryService.cs b/src/EditorFeatures/Core/Extensibility/NavigationBar/INavigationBarControllerFactoryService.cs
index f5516183c958b..0ff6f947d5f33 100644
--- a/src/EditorFeatures/Core/Extensibility/NavigationBar/INavigationBarControllerFactoryService.cs
+++ b/src/EditorFeatures/Core/Extensibility/NavigationBar/INavigationBarControllerFactoryService.cs
@@ -4,12 +4,13 @@
 
 #nullable disable
 
+using System;
 using Microsoft.VisualStudio.Text;
 
 namespace Microsoft.CodeAnalysis.Editor
 {
     internal interface INavigationBarControllerFactoryService
     {
-        INavigationBarController CreateController(INavigationBarPresenter presenter, ITextBuffer textBuffer);
+        IDisposable CreateController(INavigationBarPresenter presenter, ITextBuffer textBuffer);
     }
 }
diff --git a/src/EditorFeatures/Core/ExternalAccess/IntelliCode/Api/IIntelliCodeArgumentDefaultsSource.cs b/src/EditorFeatures/Core/ExternalAccess/IntelliCode/Api/IIntelliCodeArgumentDefaultsSource.cs
new file mode 100644
index 0000000000000..7ac6a9ac08fe5
--- /dev/null
+++ b/src/EditorFeatures/Core/ExternalAccess/IntelliCode/Api/IIntelliCodeArgumentDefaultsSource.cs
@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.IntelliCode.Api
+{
+    /// <summary>
+    /// Provides a list of possible default arguments for method calls.
+    /// </summary>
+    /// <remarks>
+    /// This is a MEF component and should be exported with <see cref="ContentTypeAttribute"/> and <see cref="NameAttribute"/> attributes
+    /// and optional <see cref="OrderAttribute"/> and <see cref="TextViewRoleAttribute"/> attributes.
+    /// An instance of <see cref="IIntelliCodeArgumentDefaultsSource"/> is selected
+    /// first by matching ContentType with content type of the <see cref="ITextView.TextBuffer"/>, and then by order.
+    /// Only one <see cref="IIntelliCodeArgumentDefaultsSource"/> is used in a given view.
+    /// <para>
+    /// Only one <see cref="IIntelliCodeArgumentDefaultsSource"/> will used for any given <see cref="ITextView"/>. The sources are
+    /// ordered by the Order attribute. The first source (if any) that satisfies the ContentType and TextViewRoles
+    /// attributes will be the source used to provide defaults.
+    /// </para>
+    /// <example>
+    /// <code>
+    ///     [Export(typeof(IIntelliCodeArgumentDefaultsSource))]
+    ///     [Name(nameof(IntelliCodeArgumentDefaultsSource))]
+    ///     [ContentType("text")]
+    ///     [TextViewRoles(PredefinedTextViewRoles.Editable)]
+    ///     [Order(Before = "OtherCompletionDefaultsSource")]
+    ///     public class IntelliCodeArgumentDefaultsSource : IIntelliCodeArgumentDefaultsSource
+    /// </code>
+    /// </example>
+    /// </remarks>
+    internal interface IIntelliCodeArgumentDefaultsSource
+    {
+        /// <summary>
+        /// Gets a list of possible default arguments for a method signature.
+        /// </summary>
+        /// <param name="view">View for which the defaults are desired.</param>
+        /// <returns>A list of possible default arguments for a method signature.</returns>
+        /// <remarks>
+        /// <para>The returned value will always be in the form of a "complete" set of arguments, including the leading and trailing parenthesis.</para>
+        /// <para>For example:
+        /// <code>
+        /// ()
+        /// (args[0])
+        /// (args.Length)
+        /// (value: args.Length)
+        /// </code>
+        /// </para>
+        /// <para>Some of the proposals may be syntactically/semantically invalid (and can be ignored by the caller).</para>
+        /// </remarks>
+        Task<ImmutableArray<string>> GetArgumentDefaultsAsync(ITextView view);
+    }
+}
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptFormattingInteractionService.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptFormattingInteractionService.cs
index bdcff8b3229bc..8b6f154e38c29 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptFormattingInteractionService.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptFormattingInteractionService.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptFormattingInteractionService.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptFormattingInteractionService.cs
index d4b2ab1481110..6a6bb7990ca23 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptFormattingInteractionService.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptFormattingInteractionService.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/EditorFeatures/Core/Implementation/Classification/CompilationAvailableTaggerEventSource.cs b/src/EditorFeatures/Core/Implementation/Classification/CompilationAvailableTaggerEventSource.cs
index 5abc902357394..1a16c9bd21c35 100644
--- a/src/EditorFeatures/Core/Implementation/Classification/CompilationAvailableTaggerEventSource.cs
+++ b/src/EditorFeatures/Core/Implementation/Classification/CompilationAvailableTaggerEventSource.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Threading;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.Classification
@@ -86,7 +87,11 @@ private void OnEventSourceChanged(object? sender, TaggerEventArgs args)
             var token = _asyncListener.BeginAsyncOperation(nameof(OnEventSourceChanged));
             var task = Task.Run(async () =>
             {
-                await Task.Delay(500, cancellationToken).ConfigureAwait(false);
+                // Support cancellation without throwing
+                await _asyncListener.Delay(TimeSpan.FromMilliseconds(500), cancellationToken).NoThrowAwaitable(captureContext: false);
+                if (cancellationToken.IsCancellationRequested)
+                    return;
+
                 await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
                 this.Changed?.Invoke(this, new TaggerEventArgs());
             }, cancellationToken);
diff --git a/src/EditorFeatures/Core/Implementation/Classification/SyntacticClassificationTaggerProvider.TagComputer.cs b/src/EditorFeatures/Core/Implementation/Classification/SyntacticClassificationTaggerProvider.TagComputer.cs
index d4d083cd5eaca..ef3376af8d8d1 100644
--- a/src/EditorFeatures/Core/Implementation/Classification/SyntacticClassificationTaggerProvider.TagComputer.cs
+++ b/src/EditorFeatures/Core/Implementation/Classification/SyntacticClassificationTaggerProvider.TagComputer.cs
@@ -265,7 +265,7 @@ private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs args)
             /// the editor.  Calls to <see cref="ProcessChangesAsync"/> are serialized by <see cref="AsyncBatchingWorkQueue{TItem}"/>
             /// so we don't need to worry about multiple calls to this happening concurrently.
             /// </summary>
-            private async Task ProcessChangesAsync(ImmutableArray<ITextSnapshot> snapshots, CancellationToken cancellationToken)
+            private async ValueTask ProcessChangesAsync(ImmutableArray<ITextSnapshot> snapshots, CancellationToken cancellationToken)
             {
                 // We have potentially heard about several changes to the subject buffer.  However
                 // we only need to process the latest once.
diff --git a/src/EditorFeatures/Core/Implementation/CodeActions/CodeActionEditHandlerService.cs b/src/EditorFeatures/Core/Implementation/CodeActions/CodeActionEditHandlerService.cs
index 067af4895568f..a7c7efc630646 100644
--- a/src/EditorFeatures/Core/Implementation/CodeActions/CodeActionEditHandlerService.cs
+++ b/src/EditorFeatures/Core/Implementation/CodeActions/CodeActionEditHandlerService.cs
@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Editor.Undo;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Navigation;
 using Microsoft.CodeAnalysis.Notification;
@@ -134,7 +135,7 @@ public bool Apply(
 
             var oldSolution = workspace.CurrentSolution;
 
-            bool applied;
+            var applied = false;
 
             // Determine if we're making a simple text edit to a single file or not.
             // If we're not, then we need to make a linked global undo to wrap the 
@@ -152,7 +153,14 @@ public bool Apply(
 
                 using (workspace.Services.GetService<ISourceTextUndoService>().RegisterUndoTransaction(text, title))
                 {
-                    applied = operations.Single().TryApply(workspace, progressTracker, cancellationToken);
+                    try
+                    {
+                        applied = operations.Single().TryApply(workspace, progressTracker, cancellationToken);
+                    }
+                    catch (Exception ex) when (FatalError.ReportAndPropagateUnlessCanceled(ex, cancellationToken))
+                    {
+                        throw ExceptionUtilities.Unreachable;
+                    }
                 }
             }
             else
@@ -169,9 +177,16 @@ public bool Apply(
                     transaction.AddDocument(fromDocument.Id);
                 }
 
-                applied = ProcessOperations(
-                    workspace, operations, progressTracker,
-                    cancellationToken);
+                try
+                {
+                    applied = ProcessOperations(
+                        workspace, operations, progressTracker,
+                        cancellationToken);
+                }
+                catch (Exception ex) when (FatalError.ReportAndPropagateUnlessCanceled(ex, cancellationToken))
+                {
+                    throw ExceptionUtilities.Unreachable;
+                }
 
                 transaction.Commit();
             }
diff --git a/src/EditorFeatures/Core/Implementation/EditAndContinue/EditAndContinueSaveFileCommandHandler.cs b/src/EditorFeatures/Core/Implementation/EditAndContinue/EditAndContinueSaveFileCommandHandler.cs
deleted file mode 100644
index a8c80e2830e9b..0000000000000
--- a/src/EditorFeatures/Core/Implementation/EditAndContinue/EditAndContinueSaveFileCommandHandler.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.ComponentModel.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.EditAndContinue;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.Text;
-using Microsoft.VisualStudio.Commanding;
-using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
-using Microsoft.VisualStudio.Utilities;
-using Roslyn.Utilities;
-using VSCommanding = Microsoft.VisualStudio.Commanding;
-
-namespace Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue
-{
-    [Export]
-    [Export(typeof(VSCommanding.ICommandHandler))]
-    [ContentType(ContentTypeNames.RoslynContentType)]
-    [Name(PredefinedCommandHandlerNames.EditAndContinueFileSave)]
-    internal sealed class EditAndContinueSaveFileCommandHandler : IChainedCommandHandler<SaveCommandArgs>
-    {
-        [ImportingConstructor]
-        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public EditAndContinueSaveFileCommandHandler()
-        {
-        }
-
-        public string DisplayName => PredefinedCommandHandlerNames.EditAndContinueFileSave;
-
-        void IChainedCommandHandler<SaveCommandArgs>.ExecuteCommand(SaveCommandArgs args, Action nextCommandHandler, CommandExecutionContext executionContext)
-        {
-            var textContainer = args.SubjectBuffer.AsTextContainer();
-
-            if (Workspace.TryGetWorkspace(textContainer, out var workspace))
-            {
-                var documentId = workspace.GetDocumentIdInCurrentContext(textContainer);
-                if (documentId != null)
-                {
-                    // ignoring source-generated files since they shouldn't be modified and saved:
-                    var currentDocument = workspace.CurrentSolution.GetDocument(documentId);
-                    if (currentDocument != null)
-                    {
-                        var proxy = new RemoteEditAndContinueServiceProxy(workspace);
-
-                        // fire and forget
-                        _ = Task.Run(() => proxy.OnSourceFileUpdatedAsync(currentDocument, CancellationToken.None)).ReportNonFatalErrorAsync();
-                    }
-                }
-            }
-
-            nextCommandHandler();
-        }
-
-        public VSCommanding.CommandState GetCommandState(SaveCommandArgs args, Func<VSCommanding.CommandState> nextCommandHandler)
-            => nextCommandHandler();
-    }
-}
-
diff --git a/src/EditorFeatures/Core/Implementation/InlineRename/InlineRenameSession.cs b/src/EditorFeatures/Core/Implementation/InlineRename/InlineRenameSession.cs
index cc279135ac9bd..3cade421d1aa6 100644
--- a/src/EditorFeatures/Core/Implementation/InlineRename/InlineRenameSession.cs
+++ b/src/EditorFeatures/Core/Implementation/InlineRename/InlineRenameSession.cs
@@ -229,6 +229,7 @@ private void InitializeOpenBuffers(SnapshotSpan triggerSpan)
                         FatalError.ReportAndCatch(new NullTextBufferException(document, text));
                         continue;
                     }
+
                     Contract.ThrowIfNull(textSnapshot.TextBuffer);
 
                     openBuffers.Add(textSnapshot.TextBuffer);
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSource.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSource.cs
index d8069ec1f6559..bf42006821e29 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSource.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSource.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Completion.Providers;
 using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Experiments;
@@ -373,7 +374,8 @@ private bool TryInvokeSnippetCompletion(
 
             var description = await service.GetDescriptionAsync(document, roslynItem, cancellationToken).ConfigureAwait(false);
 
-            var elements = IntelliSense.Helpers.BuildInteractiveTextElements(description.TaggedParts, document, ThreadingContext, _streamingPresenter).ToArray();
+            var context = new IntellisenseQuickInfoBuilderContext(document, ThreadingContext, _streamingPresenter);
+            var elements = IntelliSense.Helpers.BuildInteractiveTextElements(description.TaggedParts, context).ToArray();
             if (elements.Length == 0)
             {
                 return new ClassifiedTextElement();
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/Helpers.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/Helpers.cs
index 3373f45cb33f9..ffce116fbf189 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/Helpers.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/Helpers.cs
@@ -144,13 +144,6 @@ internal static bool IsStandardCommitCharacter(char c)
         internal static bool TryGetInitialTriggerLocation(EditorAsyncCompletion.IAsyncCompletionSession session, out SnapshotPoint initialTriggerLocation)
             => session.Properties.TryGetProperty(CompletionSource.TriggerLocation, out initialTriggerLocation);
 
-        // This is a temporarily method to support preference of IntelliCode items comparing to non-IntelliCode items.
-        // We expect that Editor will introduce this support and we will get rid of relying on the "★" then.
-        // We check both the display text and the display text prefix to account for IntelliCode item providers
-        // that may be using the prefix to include the ★.
-        internal static bool IsPreferredItem(this RoslynCompletionItem completionItem)
-            => completionItem.DisplayText.StartsWith("★") || completionItem.DisplayTextPrefix.StartsWith("★");
-
         // This is a temporarily method to support preference of IntelliCode items comparing to non-IntelliCode items.
         // We expect that Editor will introduce this support and we will get rid of relying on the "★" then.
         internal static bool IsPreferredItem(this VSCompletionItem completionItem)
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
index 2180361d30d65..c8d8a09ae3939 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
@@ -84,7 +84,7 @@ public Task<ImmutableArray<VSCompletionItem>> SortCompletionListAsync(
         // Set the size of pool to 1 because we don't expect UpdateCompletionListAsync to be
         // called concurrently, which essentially makes the pooled list a singleton,
         // but we still use ObjectPool for concurrency handling just to be robust.
-        private static readonly ObjectPool<List<MatchResult>> s_listOfMatchResultPool
+        private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool
                 = new(factory: () => new(), size: 1);
 
         private FilteredCompletionModel? UpdateCompletionList(
@@ -208,10 +208,11 @@ private static readonly ObjectPool<List<MatchResult>> s_listOfMatchResultPool
                         filterReason,
                         _recentItemsManager.RecentItems,
                         highlightMatchingPortions: highlightMatchingPortions,
-                        ref currentIndex,
+                        currentIndex,
                         out var matchResult))
                     {
                         initialListOfItemsToBeIncluded.Add(matchResult);
+                        currentIndex++;
                     }
                 }
 
@@ -224,7 +225,7 @@ private static readonly ObjectPool<List<MatchResult>> s_listOfMatchResultPool
                 // Note that we want to preserve the original alphabetical order for items with same pattern match score,
                 // but `List<T>.Sort` isn't stable. Therefore we have to add a monotonically increasing integer
                 // to `MatchResult` to achieve this.
-                initialListOfItemsToBeIncluded.Sort(MatchResult.SortingComparer);
+                initialListOfItemsToBeIncluded.Sort(MatchResult<VSCompletionItem>.SortingComparer);
 
                 var showCompletionItemFilters = options?.GetOption(CompletionOptions.ShowCompletionItemFilters, document?.Project.Language) ?? true;
 
@@ -235,7 +236,7 @@ private static readonly ObjectPool<List<MatchResult>> s_listOfMatchResultPool
                 // If this was deletion, then we control the entire behavior of deletion ourselves.
                 if (initialRoslynTriggerKind == CompletionTriggerKind.Deletion)
                 {
-                    return HandleDeletionTrigger(data.Trigger.Reason, initialListOfItemsToBeIncluded, filterText, updatedFilters, hasSuggestedItemOptions);
+                    return HandleDeletionTrigger(reason, initialListOfItemsToBeIncluded, filterText, updatedFilters, hasSuggestedItemOptions, highlightMatchingPortions, completionHelper);
                 }
 
                 Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> filterMethod;
@@ -255,7 +256,9 @@ private static readonly ObjectPool<List<MatchResult>> s_listOfMatchResultPool
                     filterReason,
                     data.Trigger.Character,
                     initialListOfItemsToBeIncluded,
-                    hasSuggestedItemOptions);
+                    hasSuggestedItemOptions,
+                    highlightMatchingPortions,
+                    completionHelper);
             }
             finally
             {
@@ -310,8 +313,10 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
             ImmutableArray<CompletionFilterWithState> filters,
             CompletionFilterReason filterReason,
             char typeChar,
-            List<MatchResult> itemsInList,
-            bool hasSuggestedItemOptions)
+            List<MatchResult<VSCompletionItem>> itemsInList,
+            bool hasSuggestedItemOptions,
+            bool highlightMatchingPortions,
+            CompletionHelper completionHelper)
         {
             // Not deletion.  Defer to the language to decide which item it thinks best
             // matches the text typed so far.
@@ -324,7 +329,7 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
 
             int selectedItemIndex;
             VSCompletionItem? uniqueItem = null;
-            MatchResult bestOrFirstMatchResult;
+            MatchResult<VSCompletionItem> bestOrFirstMatchResult;
 
             if (chosenItems.Length == 0)
             {
@@ -367,7 +372,7 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
                 if (deduplicatedListCount == 1 &&
                     filterText.Length > 0)
                 {
-                    uniqueItem = itemsInList[selectedItemIndex].VSCompletionItem;
+                    uniqueItem = itemsInList[selectedItemIndex].EditorCompletionItem;
                 }
             }
 
@@ -390,16 +395,18 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
             var updateSelectionHint = isHardSelection ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected;
 
             return new FilteredCompletionModel(
-                GetHighlightedList(itemsInList), selectedItemIndex, filters,
+                GetHighlightedList(itemsInList, filterText, highlightMatchingPortions, completionHelper), selectedItemIndex, filters,
                 updateSelectionHint, centerSelection: true, uniqueItem);
         }
 
         private static FilteredCompletionModel? HandleDeletionTrigger(
             CompletionTriggerReason filterTriggerKind,
-            List<MatchResult> matchResults,
+            List<MatchResult<VSCompletionItem>> matchResults,
             string filterText,
             ImmutableArray<CompletionFilterWithState> filters,
-            bool hasSuggestedItemOptions)
+            bool hasSuggestedItemOptions,
+            bool highlightMatchingSpans,
+            CompletionHelper completionHelper)
         {
             var matchingItems = matchResults.Where(r => r.MatchedFilterText);
             if (filterTriggerKind == CompletionTriggerReason.Insertion &&
@@ -414,7 +421,7 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
                 return null;
             }
 
-            MatchResult? bestMatchResult = null;
+            MatchResult<VSCompletionItem>? bestMatchResult = null;
             var moreThanOneMatchWithSamePriority = false;
             foreach (var currentMatchResult in matchingItems)
             {
@@ -453,7 +460,7 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
                 //   text that originally appeared before the dot
                 // * deleting through a word from the end keeps that word selected
                 // This also preserves the behavior the VB had through Dev12.
-                hardSelect = !hasSuggestedItemOptions && bestMatchResult.Value.VSCompletionItem.FilterText.StartsWith(filterText, StringComparison.CurrentCultureIgnoreCase);
+                hardSelect = !hasSuggestedItemOptions && bestMatchResult.Value.EditorCompletionItem.FilterText.StartsWith(filterText, StringComparison.CurrentCultureIgnoreCase);
                 index = matchResults.IndexOf(bestMatchResult.Value);
             }
             else
@@ -463,15 +470,56 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
             }
 
             return new FilteredCompletionModel(
-                GetHighlightedList(matchResults), index, filters,
+                GetHighlightedList(matchResults, filterText, highlightMatchingSpans, completionHelper), index, filters,
                 hardSelect ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected,
                 centerSelection: true,
-                uniqueItem: moreThanOneMatchWithSamePriority ? null : bestMatchResult.GetValueOrDefault().VSCompletionItem);
+                uniqueItem: moreThanOneMatchWithSamePriority ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
         }
 
-        private static ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(List<MatchResult> matchResults)
-            => matchResults.SelectAsArray(matchResult =>
-            new CompletionItemWithHighlight(matchResult.VSCompletionItem, matchResult.HighlightedSpans));
+        private static ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(
+            List<MatchResult<VSCompletionItem>> matchResults,
+            string filterText,
+            bool highlightMatchingPortions,
+            CompletionHelper completionHelper)
+        {
+            return matchResults.SelectAsArray(matchResult =>
+            {
+                var highlightedSpans = GetHighlightedSpans(matchResult, completionHelper, filterText, highlightMatchingPortions);
+                return new CompletionItemWithHighlight(matchResult.EditorCompletionItem, highlightedSpans);
+            });
+
+            static ImmutableArray<Span> GetHighlightedSpans(
+                MatchResult<VSCompletionItem> matchResult,
+                CompletionHelper completionHelper,
+                string filterText,
+                bool highlightMatchingPortions)
+            {
+                if (highlightMatchingPortions)
+                {
+                    if (matchResult.RoslynCompletionItem.HasDifferentFilterText)
+                    {
+                        // The PatternMatch in MatchResult is calculated based on Roslyn item's FilterText, 
+                        // which can be used to calculate highlighted span for VSCompletion item's DisplayText w/o doing the matching again.
+                        // However, if the Roslyn item's FilterText is different from its DisplayText,
+                        // we need to do the match against the display text of the VS item directly to get the highlighted spans.
+                        return completionHelper.GetHighlightedSpans(
+                            matchResult.EditorCompletionItem.DisplayText, filterText, CultureInfo.CurrentCulture).SelectAsArray(s => s.ToSpan());
+                    }
+
+                    var patternMatch = matchResult.PatternMatch;
+                    if (patternMatch.HasValue)
+                    {
+                        // Since VS item's display text is created as Prefix + DisplayText + Suffix, 
+                        // we can calculate the highlighted span by adding an offset that is the length of the Prefix.
+                        return patternMatch.Value.MatchedSpans.SelectAsArray(s_highlightSpanGetter, matchResult.RoslynCompletionItem);
+                    }
+                }
+
+                // If there's no match for Roslyn item's filter text which is identical to its display text,
+                // then we can safely assume there'd be no matching to VS item's display text.
+                return ImmutableArray<Span>.Empty;
+            }
+        }
 
         private static FilteredCompletionModel? HandleAllItemsFilteredOut(
             CompletionTriggerReason triggerReason,
@@ -504,12 +552,12 @@ private static ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(Li
         }
 
         private static ImmutableArray<CompletionFilterWithState> GetUpdatedFilters(
-            List<MatchResult> filteredList,
+            List<MatchResult<VSCompletionItem>> filteredList,
             ImmutableArray<CompletionFilterWithState> filters)
         {
             // See which filters might be enabled based on the typed code
             using var _ = PooledHashSet<CompletionFilter>.GetInstance(out var textFilteredFilters);
-            textFilteredFilters.AddRange(filteredList.SelectMany(n => n.VSCompletionItem.Filters));
+            textFilteredFilters.AddRange(filteredList.SelectMany(n => n.EditorCompletionItem.Filters));
 
             // When no items are available for a given filter, it becomes unavailable.
             // Expanders always appear available as long as it's presented.
@@ -584,21 +632,6 @@ private static RoslynCompletionItem GetOrAddRoslynCompletionItem(VSCompletionIte
             return roslynItem;
         }
 
-        // If the item didn't match the filter text, we still keep it in the list
-        // if one of two things is true:
-        //  1. The user has typed nothing or only typed a single character.  In this case they might
-        //     have just typed the character to get completion.  Filtering out items
-        //     here is not desirable.
-        //
-        //  2. They brought up completion with ctrl-j or through deletion.  In these
-        //     cases we just always keep all the items in the list.
-        private static bool KeepAllItemsInTheList(CompletionTriggerKind initialTriggerKind, string filterText)
-        {
-            return filterText.Length <= 1 ||
-                initialTriggerKind == CompletionTriggerKind.Invoke ||
-                initialTriggerKind == CompletionTriggerKind.Deletion;
-        }
-
         private static bool TryCreateMatchResult(
             CompletionHelper completionHelper,
             VSCompletionItem item,
@@ -607,122 +640,17 @@ private static bool TryCreateMatchResult(
             CompletionFilterReason filterReason,
             ImmutableArray<string> recentItems,
             bool highlightMatchingPortions,
-            ref int currentIndex,
-            out MatchResult matchResult)
+            int currentIndex,
+            out MatchResult<VSCompletionItem> matchResult)
         {
             var roslynItem = GetOrAddRoslynCompletionItem(item);
-
-            // Get the match of the given completion item for the pattern provided so far. 
-            // A completion item is checked against the pattern by see if it's 
-            // CompletionItem.FilterText matches the item. That way, the pattern it checked 
-            // against terms like "IList" and not IList<>.
-            // Note that the check on filter text length is purely for efficiency, we should 
-            // get the same result with or without it.
-            var patternMatch = filterText.Length > 0
-                ? completionHelper.GetMatch(item.FilterText, filterText, includeMatchSpans: highlightMatchingPortions, CultureInfo.CurrentCulture)
-                : null;
-
-            var matchedFilterText = MatchesFilterText(
-                roslynItem,
-                filterText,
-                initialTriggerKind,
-                filterReason,
-                recentItems,
-                patternMatch);
-
-            if (matchedFilterText || KeepAllItemsInTheList(initialTriggerKind, filterText))
-            {
-                matchResult = new MatchResult(
-                    roslynItem, item, matchedFilterText: matchedFilterText,
-                    patternMatch: patternMatch, index: currentIndex++, GetHighlightedSpans(completionHelper, item, filterText, highlightMatchingPortions, roslynItem, patternMatch));
-
-                return true;
-            }
-
-            matchResult = default;
-            return false;
-
-            static ImmutableArray<Span> GetHighlightedSpans(
-                CompletionHelper completionHelper,
-                VSCompletionItem item,
-                string filterText,
-                bool highlightMatchingPortions,
-                RoslynCompletionItem roslynItem,
-                PatternMatch? patternMatch)
-            {
-                if (!highlightMatchingPortions)
-                {
-                    return ImmutableArray<Span>.Empty;
-                }
-
-                if (roslynItem.HasDifferentFilterText)
-                {
-                    // The PatternMatch in MatchResult is calculated based on Roslyn item's FilterText, 
-                    // which can be used to calculate highlighted span for VSCompletion item's DisplayText w/o doing the matching again.
-                    // However, if the Roslyn item's FilterText is different from its DisplayText,
-                    // we need to do the match against the display text of the VS item directly to get the highlighted spans.
-                    return completionHelper.GetHighlightedSpans(
-                        item.DisplayText, filterText, CultureInfo.CurrentCulture).SelectAsArray(s => s.ToSpan());
-                }
-
-                if (patternMatch.HasValue)
-                {
-                    // Since VS item's display text is created as Prefix + DisplayText + Suffix, 
-                    // we can calculate the highlighted span by adding an offset that is the length of the Prefix.
-                    return patternMatch.Value.MatchedSpans
-                        .SelectAsArray(s_highlightSpanGetter, roslynItem);
-                }
-
-                // If there's no match for Roslyn item's filter text which is identical to its display text,
-                // then we can safely assume there'd be no matching to VS item's display text.
-                return ImmutableArray<Span>.Empty;
-            }
+            return CompletionHelper.TryCreateMatchResult(completionHelper, roslynItem, item, filterText, initialTriggerKind, filterReason, recentItems, highlightMatchingPortions, currentIndex, out matchResult);
         }
 
         // PERF: Create a singleton to avoid lambda allocation on hot path
         private static readonly Func<TextSpan, RoslynCompletionItem, Span> s_highlightSpanGetter
             = (span, item) => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
 
-        private static bool MatchesFilterText(
-            RoslynCompletionItem item,
-            string filterText,
-            CompletionTriggerKind initialTriggerKind,
-            CompletionFilterReason filterReason,
-            ImmutableArray<string> recentItems,
-            PatternMatch? patternMatch)
-        {
-            // For the deletion we bake in the core logic for how matching should work.
-            // This way deletion feels the same across all languages that opt into deletion 
-            // as a completion trigger.
-
-            // Specifically, to avoid being too aggressive when matching an item during 
-            // completion, we require that the current filter text be a prefix of the 
-            // item in the list.
-            if (filterReason == CompletionFilterReason.Deletion &&
-                initialTriggerKind == CompletionTriggerKind.Deletion)
-            {
-                return item.FilterText.GetCaseInsensitivePrefixLength(filterText) > 0;
-            }
-
-            // If the user hasn't typed anything, and this item was preselected, or was in the
-            // MRU list, then we definitely want to include it.
-            if (filterText.Length == 0)
-            {
-                if (item.Rules.MatchPriority > MatchPriority.Default)
-                {
-                    return true;
-                }
-
-                if (!recentItems.IsDefault && GetRecentItemIndex(recentItems, item) <= 0)
-                {
-                    return true;
-                }
-            }
-
-            // Otherwise, the item matches filter text if a pattern match is returned.
-            return patternMatch != null;
-        }
-
         private static bool IsHardSelection(
             string filterText,
             RoslynCompletionItem item,
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs
index 629e21ae5fa55..6e9ceb2cf3624 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs
@@ -22,20 +22,16 @@ internal static class Helpers
     {
         internal static IReadOnlyCollection<object> BuildInteractiveTextElements(
             ImmutableArray<TaggedText> taggedTexts,
-            Document document,
-            IThreadingContext threadingContext,
-            Lazy<IStreamingFindUsagesPresenter> streamingPresenter)
+            IntellisenseQuickInfoBuilderContext? context)
         {
             var index = 0;
-            return BuildInteractiveTextElements(taggedTexts, ref index, document, threadingContext, streamingPresenter);
+            return BuildInteractiveTextElements(taggedTexts, ref index, context);
         }
 
         private static IReadOnlyCollection<object> BuildInteractiveTextElements(
             ImmutableArray<TaggedText> taggedTexts,
             ref int index,
-            Document document,
-            IThreadingContext? threadingContext,
-            Lazy<IStreamingFindUsagesPresenter>? streamingPresenter)
+            IntellisenseQuickInfoBuilderContext? context)
         {
             // This method produces a sequence of zero or more paragraphs
             var paragraphs = new List<object>();
@@ -67,7 +63,7 @@ private static IReadOnlyCollection<object> BuildInteractiveTextElements(
                     }
 
                     index++;
-                    var nestedElements = BuildInteractiveTextElements(taggedTexts, ref index, document, threadingContext, streamingPresenter);
+                    var nestedElements = BuildInteractiveTextElements(taggedTexts, ref index, context);
                     if (nestedElements.Count <= 1)
                     {
                         currentParagraph.Add(new ContainerElement(
@@ -136,8 +132,11 @@ private static IReadOnlyCollection<object> BuildInteractiveTextElements(
                 {
                     // This is tagged text getting added to the current line we are building.
                     var style = GetClassifiedTextRunStyle(part.Style);
-                    if (part.NavigationTarget is object && streamingPresenter != null && threadingContext != null)
+                    if (part.NavigationTarget is object &&
+                        context?.ThreadingContext is ThreadingContext threadingContext &&
+                        context.StreamingPresenter is Lazy<IStreamingFindUsagesPresenter> streamingPresenter)
                     {
+                        var document = context.Document;
                         if (Uri.TryCreate(part.NavigationTarget, UriKind.Absolute, out var absoluteUri))
                         {
                             var target = new QuickInfoHyperLink(document.Project.Solution.Workspace, absoluteUri);
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs
index a313b77bd03c8..89a300097727c 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -27,9 +25,7 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo
     internal static class IntellisenseQuickInfoBuilder
     {
         private static async Task<ContainerElement> BuildInteractiveContentAsync(CodeAnalysisQuickInfoItem quickInfoItem,
-            Document document,
-            IThreadingContext threadingContext,
-            Lazy<IStreamingFindUsagesPresenter> streamingPresenter,
+            IntellisenseQuickInfoBuilderContext? context,
             CancellationToken cancellationToken)
         {
             // Build the first line of QuickInfo item, the images and the Description section should be on the first line with Wrapped style
@@ -52,7 +48,7 @@ private static async Task<ContainerElement> BuildInteractiveContentAsync(CodeAna
             if (descSection != null)
             {
                 var isFirstElement = true;
-                foreach (var element in Helpers.BuildInteractiveTextElements(descSection.TaggedParts, document, threadingContext, streamingPresenter))
+                foreach (var element in Helpers.BuildInteractiveTextElements(descSection.TaggedParts, context))
                 {
                     if (isFirstElement)
                     {
@@ -74,7 +70,7 @@ private static async Task<ContainerElement> BuildInteractiveContentAsync(CodeAna
             if (documentationCommentSection != null)
             {
                 var isFirstElement = true;
-                foreach (var element in Helpers.BuildInteractiveTextElements(documentationCommentSection.TaggedParts, document, threadingContext, streamingPresenter))
+                foreach (var element in Helpers.BuildInteractiveTextElements(documentationCommentSection.TaggedParts, context))
                 {
                     if (isFirstElement)
                     {
@@ -98,10 +94,10 @@ private static async Task<ContainerElement> BuildInteractiveContentAsync(CodeAna
             // Add the remaining sections as Stacked style
             elements.AddRange(
                 quickInfoItem.Sections.Where(s => s.Kind != QuickInfoSectionKinds.Description && s.Kind != QuickInfoSectionKinds.DocumentationComments)
-                                      .SelectMany(s => Helpers.BuildInteractiveTextElements(s.TaggedParts, document, threadingContext, streamingPresenter)));
+                                      .SelectMany(s => Helpers.BuildInteractiveTextElements(s.TaggedParts, context)));
 
             // build text for RelatedSpan
-            if (quickInfoItem.RelatedSpans.Any())
+            if (quickInfoItem.RelatedSpans.Any() && context?.Document is Document document)
             {
                 var classifiedSpanList = new List<ClassifiedSpan>();
                 foreach (var span in quickInfoItem.RelatedSpans)
@@ -134,7 +130,8 @@ internal static async Task<IntellisenseQuickInfoItem> BuildItemAsync(
             Lazy<IStreamingFindUsagesPresenter> streamingPresenter,
             CancellationToken cancellationToken)
         {
-            var content = await BuildInteractiveContentAsync(quickInfoItem, document, threadingContext, streamingPresenter, cancellationToken).ConfigureAwait(false);
+            var context = new IntellisenseQuickInfoBuilderContext(document, threadingContext, streamingPresenter);
+            var content = await BuildInteractiveContentAsync(quickInfoItem, context, cancellationToken).ConfigureAwait(false);
 
             return new IntellisenseQuickInfoItem(trackingSpan, content);
         }
@@ -147,10 +144,10 @@ internal static async Task<IntellisenseQuickInfoItem> BuildItemAsync(
         /// </summary>
         internal static Task<ContainerElement> BuildContentWithoutNavigationActionsAsync(
             CodeAnalysisQuickInfoItem quickInfoItem,
-            Document document,
+            IntellisenseQuickInfoBuilderContext? context,
             CancellationToken cancellationToken)
         {
-            return BuildInteractiveContentAsync(quickInfoItem, document, threadingContext: null, streamingPresenter: null, cancellationToken);
+            return BuildInteractiveContentAsync(quickInfoItem, context, cancellationToken);
         }
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilderContext.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilderContext.cs
new file mode 100644
index 0000000000000..ca453d49c4b66
--- /dev/null
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilderContext.cs
@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo
+{
+    /// <summary>
+    /// Context to build content for quick info item for intellisense.
+    /// </summary>
+    internal sealed class IntellisenseQuickInfoBuilderContext
+    {
+        public IntellisenseQuickInfoBuilderContext(
+            Document document,
+            IThreadingContext? threadingContext,
+            Lazy<IStreamingFindUsagesPresenter>? streamingPresenter)
+        {
+            Document = document;
+            ThreadingContext = threadingContext;
+            StreamingPresenter = streamingPresenter;
+        }
+
+        public Document Document { get; }
+        public IThreadingContext? ThreadingContext { get; }
+        public Lazy<IStreamingFindUsagesPresenter>? StreamingPresenter { get; }
+    }
+}
diff --git a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController.cs b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController.cs
index a645f439539ea..e43ae4c6a9b80 100644
--- a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController.cs
+++ b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController.cs
@@ -3,13 +3,16 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.Implementation.Classification;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Editor.Tagging;
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -28,7 +31,7 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.NavigationBar
     /// The threading model for this class is simple: all non-static members are affinitized to the
     /// UI thread.
     /// </remarks>
-    internal partial class NavigationBarController : ForegroundThreadAffinitizedObject, INavigationBarController
+    internal partial class NavigationBarController : ForegroundThreadAffinitizedObject, IDisposable
     {
         private readonly INavigationBarPresenter _presenter;
         private readonly ITextBuffer _subjectBuffer;
@@ -36,12 +39,11 @@ internal partial class NavigationBarController : ForegroundThreadAffinitizedObje
         private readonly IAsynchronousOperationListener _asyncListener;
 
         private bool _disconnected = false;
-        private Workspace? _workspace;
 
         /// <summary>
-        /// Latest model and selected items produced once <see cref="DetermineSelectedItemInfoAsync"/> completes and
-        /// presents the single item to the view.  These can then be read in when the dropdown is expanded and we want
-        /// to show all items.
+        /// Latest model and selected items produced once <see cref="SelectItemAsync"/> completes and presents the
+        /// single item to the view.  These can then be read in when the dropdown is expanded and we want to show all
+        /// items.
         /// </summary>
         private (NavigationBarModel model, NavigationBarSelectedTypeAndMember selectedInfo) _latestModelAndSelectedInfo_OnlyAccessOnUIThread;
 
@@ -51,6 +53,26 @@ internal partial class NavigationBarController : ForegroundThreadAffinitizedObje
         /// </summary>
         private (ImmutableArray<NavigationBarProjectItem> projectItems, NavigationBarProjectItem? selectedProjectItem, NavigationBarModel model, NavigationBarSelectedTypeAndMember selectedInfo) _lastPresentedInfo;
 
+        /// <summary>
+        /// Source of events that should cause us to update the nav bar model with new information.
+        /// </summary>
+        private readonly ITaggerEventSource _eventSource;
+
+        private readonly CancellationTokenSource _cancellationTokenSource = new();
+
+        /// <summary>
+        /// Queue to batch up work to do to compute the current model.  Used so we can batch up a lot of events and only
+        /// compute the model once for every batch.  The <c>bool</c> type parameter isn't used, but is provided as this
+        /// type is generic.
+        /// </summary>
+        private readonly AsyncBatchingWorkQueue<bool, NavigationBarModel> _computeModelQueue;
+
+        /// <summary>
+        /// Queue to batch up work to do to determine the selected item.  Used so we can batch up a lot of events and
+        /// only compute the selected item once for every batch.
+        /// </summary>
+        private readonly AsyncBatchingWorkQueue _selectItemQueue;
+
         public NavigationBarController(
             IThreadingContext threadingContext,
             INavigationBarPresenter presenter,
@@ -64,86 +86,57 @@ public NavigationBarController(
             _uiThreadOperationExecutor = uiThreadOperationExecutor;
             _asyncListener = asyncListener;
 
+            _computeModelQueue = new AsyncBatchingWorkQueue<bool, NavigationBarModel>(
+                TimeSpan.FromMilliseconds(TaggerConstants.ShortDelay),
+                ComputeModelAndSelectItemAsync,
+                EqualityComparer<bool>.Default,
+                asyncListener,
+                _cancellationTokenSource.Token);
+
+            _selectItemQueue = new AsyncBatchingWorkQueue(
+                TimeSpan.FromMilliseconds(TaggerConstants.NearImmediateDelay),
+                SelectItemAsync,
+                asyncListener,
+                _cancellationTokenSource.Token);
+
             presenter.CaretMoved += OnCaretMoved;
             presenter.ViewFocused += OnViewFocused;
 
             presenter.DropDownFocused += OnDropDownFocused;
             presenter.ItemSelected += OnItemSelected;
 
-            subjectBuffer.PostChanged += OnSubjectBufferPostChanged;
-
             // Initialize the tasks to be an empty model so we never have to deal with a null case.
-            _latestModelAndSelectedInfo_OnlyAccessOnUIThread.model = new(
-                ImmutableArray<NavigationBarItem>.Empty,
-                semanticVersionStamp: default,
-                itemService: null!);
+            _latestModelAndSelectedInfo_OnlyAccessOnUIThread.model = new(ImmutableArray<NavigationBarItem>.Empty, itemService: null!);
             _latestModelAndSelectedInfo_OnlyAccessOnUIThread.selectedInfo = new(typeItem: null, memberItem: null);
 
-            _modelTask = Task.FromResult(_latestModelAndSelectedInfo_OnlyAccessOnUIThread.model);
-        }
-
-        public void SetWorkspace(Workspace? newWorkspace)
-        {
-            DisconnectFromWorkspace();
-
-            if (newWorkspace != null)
-            {
-                ConnectToWorkspace(newWorkspace);
-            }
-        }
-
-        private void ConnectToWorkspace(Workspace workspace)
-        {
-            // If we disconnected before the workspace ever connected, just disregard
-            if (_disconnected)
-            {
-                return;
-            }
-
-            _workspace = workspace;
-            _workspace.WorkspaceChanged += this.OnWorkspaceChanged;
-            _workspace.DocumentActiveContextChanged += this.OnDocumentActiveContextChanged;
-
-            if (IsForeground())
-            {
-                ConnectToNewWorkspace();
-            }
-            else
-            {
-                var asyncToken = _asyncListener.BeginAsyncOperation(nameof(ConnectToWorkspace));
-                Task.Run(async () =>
-                {
-                    await ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
-
-                    ConnectToNewWorkspace();
-                }).CompletesAsyncOperation(asyncToken);
-            }
-
-            return;
-
-            void ConnectToNewWorkspace()
-            {
-                // For the first time you open the file, we'll start immediately
-                StartModelUpdateAndSelectedItemUpdateTasks(modelUpdateDelay: 0);
-            }
+            // Use 'compilation available' as that may produce different results from the initial 'frozen partial'
+            // snapshot we use.
+            _eventSource = new CompilationAvailableTaggerEventSource(
+                subjectBuffer,
+                asyncListener,
+                // Any time an edit happens, recompute as the nav bar items may have changed.
+                TaggerEventSources.OnTextChanged(subjectBuffer),
+                // Switching what is the active context may change the nav bar contents.
+                TaggerEventSources.OnDocumentActiveContextChanged(subjectBuffer),
+                // Many workspace changes may need us to change the items (like options changing, or project renaming).
+                TaggerEventSources.OnWorkspaceChanged(subjectBuffer, asyncListener),
+                // Once we hook this buffer up to the workspace, then we can start computing the nav bar items.
+                TaggerEventSources.OnWorkspaceRegistrationChanged(subjectBuffer));
+            _eventSource.Changed += OnEventSourceChanged;
+            _eventSource.Connect();
+
+            // Kick off initial work to populate the navbars
+            StartModelUpdateAndSelectedItemUpdateTasks();
         }
 
-        private void DisconnectFromWorkspace()
+        private void OnEventSourceChanged(object? sender, TaggerEventArgs e)
         {
-            if (_workspace != null)
-            {
-                _workspace.DocumentActiveContextChanged -= this.OnDocumentActiveContextChanged;
-                _workspace.WorkspaceChanged -= this.OnWorkspaceChanged;
-                _workspace = null;
-            }
+            StartModelUpdateAndSelectedItemUpdateTasks();
         }
 
-        public void Disconnect()
+        void IDisposable.Dispose()
         {
             AssertIsForeground();
-            DisconnectFromWorkspace();
-
-            _subjectBuffer.PostChanged -= OnSubjectBufferPostChanged;
 
             _presenter.CaretMoved -= OnCaretMoved;
             _presenter.ViewFocused -= OnViewFocused;
@@ -153,81 +146,35 @@ public void Disconnect()
 
             _presenter.Disconnect();
 
+            _eventSource.Changed -= OnEventSourceChanged;
+            _eventSource.Disconnect();
+
             _disconnected = true;
 
             // Cancel off any remaining background work
-            _modelTaskCancellationSource.Cancel();
-            _selectedItemInfoTaskCancellationSource.Cancel();
+            _cancellationTokenSource.Cancel();
         }
 
-        private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs args)
+        private void StartModelUpdateAndSelectedItemUpdateTasks()
         {
-            // We're getting an event for a workspace we already disconnected from
-            if (args.NewSolution.Workspace != _workspace)
-            {
-                return;
-            }
-
-            // If the displayed project is being renamed, retrigger the update
-            if (args.Kind == WorkspaceChangeKind.ProjectChanged && args.ProjectId != null)
-            {
-                var oldProject = args.OldSolution.GetRequiredProject(args.ProjectId);
-                var newProject = args.NewSolution.GetRequiredProject(args.ProjectId);
-
-                if (oldProject.Name != newProject.Name)
-                {
-                    var currentContextDocumentId = _workspace.GetDocumentIdInCurrentContext(_subjectBuffer.AsTextContainer());
-
-                    if (currentContextDocumentId != null && currentContextDocumentId.ProjectId == args.ProjectId)
-                    {
-                        StartModelUpdateAndSelectedItemUpdateTasks(modelUpdateDelay: 0);
-                    }
-                }
-            }
-
-            if (args.Kind == WorkspaceChangeKind.DocumentChanged &&
-                args.OldSolution == args.NewSolution)
-            {
-                var currentContextDocumentId = _workspace.GetDocumentIdInCurrentContext(_subjectBuffer.AsTextContainer());
-                if (currentContextDocumentId != null && currentContextDocumentId == args.DocumentId)
-                {
-                    // The context has changed, so update everything.
-                    StartModelUpdateAndSelectedItemUpdateTasks(modelUpdateDelay: 0);
-                }
-            }
-        }
-
-        private void OnDocumentActiveContextChanged(object? sender, DocumentActiveContextChangedEventArgs args)
-        {
-            AssertIsForeground();
-            if (args.Solution.Workspace != _workspace)
+            // If we disconnected already, just disregard
+            if (_disconnected)
                 return;
 
-            var currentContextDocumentId = _workspace.GetDocumentIdInCurrentContext(_subjectBuffer.AsTextContainer());
-            if (args.NewActiveContextDocumentId == currentContextDocumentId ||
-                args.OldActiveContextDocumentId == currentContextDocumentId)
-            {
-                // if the active context changed, recompute the types/member as they may be changed as well.
-                StartModelUpdateAndSelectedItemUpdateTasks(modelUpdateDelay: 0);
-            }
-        }
-
-        private void OnSubjectBufferPostChanged(object? sender, EventArgs e)
-        {
-            AssertIsForeground();
-            StartModelUpdateAndSelectedItemUpdateTasks(modelUpdateDelay: TaggerConstants.MediumDelay);
+            // 'true' value is unused.  this just signals to the queue that we have work to do.
+            _computeModelQueue.AddWork(true);
         }
 
         private void OnCaretMoved(object? sender, EventArgs e)
         {
             AssertIsForeground();
-            StartSelectedItemUpdateTask(delay: TaggerConstants.NearImmediateDelay);
+            StartSelectedItemUpdateTask();
         }
 
         private void OnViewFocused(object? sender, EventArgs e)
         {
             AssertIsForeground();
-            StartSelectedItemUpdateTask(delay: TaggerConstants.ShortDelay);
+            StartSelectedItemUpdateTask();
         }
 
         private void OnDropDownFocused(object? sender, EventArgs e)
@@ -393,9 +340,7 @@ private async Task ProcessItemSelectionAsync(NavigationBarItem item, Cancellatio
             }
 
             // Now that the edit has been done, refresh to make sure everything is up-to-date.
-            // Have to make sure we come back to the main thread for this.
-            AssertIsForeground();
-            StartModelUpdateAndSelectedItemUpdateTasks(modelUpdateDelay: 0);
+            StartModelUpdateAndSelectedItemUpdateTasks();
         }
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarControllerFactoryService.cs b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarControllerFactoryService.cs
index 0c4460514dd88..5f7166993c57f 100644
--- a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarControllerFactoryService.cs
+++ b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarControllerFactoryService.cs
@@ -34,7 +34,7 @@ public NavigationBarControllerFactoryService(
             _asyncListener = listenerProvider.GetListener(FeatureAttribute.NavigationBar);
         }
 
-        public INavigationBarController CreateController(INavigationBarPresenter presenter, ITextBuffer textBuffer)
+        public IDisposable CreateController(INavigationBarPresenter presenter, ITextBuffer textBuffer)
         {
             return new NavigationBarController(
                 _threadingContext,
diff --git a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController_ModelComputation.cs b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController_ModelComputation.cs
index cc6ddd26ee71f..2e3f26f6f2fcd 100644
--- a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController_ModelComputation.cs
+++ b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController_ModelComputation.cs
@@ -4,17 +4,16 @@
 
 #nullable disable
 
-using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
+using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Threading;
@@ -23,155 +22,89 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.NavigationBar
 {
     internal partial class NavigationBarController
     {
-        /// <summary>
-        /// The computation of the last model.
-        /// </summary>
-        private Task<NavigationBarModel> _modelTask;
-
-        private CancellationTokenSource _modelTaskCancellationSource = new();
-        private CancellationTokenSource _selectedItemInfoTaskCancellationSource = new();
-
         /// <summary>
         /// Starts a new task to compute the model based on the current text.
         /// </summary>
-        private void StartModelUpdateAndSelectedItemUpdateTasks(int modelUpdateDelay)
+        private async ValueTask<NavigationBarModel> ComputeModelAndSelectItemAsync(ImmutableArray<bool> unused, CancellationToken cancellationToken)
         {
-            AssertIsForeground();
-
+            // Jump back to the UI thread to determine what snapshot the user is processing.
+            await this.ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
             var textSnapshot = _subjectBuffer.CurrentSnapshot;
 
-            // Cancel off any existing work
-            _modelTaskCancellationSource.Cancel();
-
-            _modelTaskCancellationSource = new CancellationTokenSource();
-            var cancellationToken = _modelTaskCancellationSource.Token;
-
-            // Enqueue a new computation for the model
-            var asyncToken = _asyncListener.BeginAsyncOperation(GetType().Name + ".StartModelUpdateTask");
-            _modelTask = ComputeModelAfterDelayAsync(_modelTask, textSnapshot, modelUpdateDelay, cancellationToken);
-            _modelTask.CompletesAsyncOperation(asyncToken);
-
-            StartSelectedItemUpdateTask(delay: 0);
-        }
-
-        private static async Task<NavigationBarModel> ComputeModelAfterDelayAsync(
-            Task<NavigationBarModel> modelTask, ITextSnapshot textSnapshot, int modelUpdateDelay, CancellationToken cancellationToken)
-        {
-            var previousModel = await modelTask.ConfigureAwait(false);
-            if (!cancellationToken.IsCancellationRequested)
-            {
-                try
-                {
-                    await Task.Delay(modelUpdateDelay, cancellationToken).ConfigureAwait(false);
-                    return await ComputeModelAsync(previousModel, textSnapshot, cancellationToken).ConfigureAwait(false);
-                }
-                catch (OperationCanceledException)
-                {
-                }
-                catch (Exception e) when (FatalError.ReportAndCatch(e))
-                {
-                }
-            }
-
-            // If we canceled, then just return along whatever we have computed so far.  Note: this means the
-            // _modelTask task will never enter the canceled state.  It always represents the last successfully
-            // computed model.
-            return previousModel;
-        }
-
-        /// <summary>
-        /// Computes a model for the given snapshot.
-        /// </summary>
-        private static async Task<NavigationBarModel> ComputeModelAsync(
-            NavigationBarModel lastCompletedModel, ITextSnapshot snapshot, CancellationToken cancellationToken)
-        {
             // Ensure we switch to the threadpool before calling GetDocumentWithFrozenPartialSemantics.  It ensures
             // that any IO that performs is not potentially on the UI thread.
             await TaskScheduler.Default;
 
-            // When computing items just get the partial semantics workspace.  This will ensure we can get data for this
-            // file, and hopefully have enough loaded to get data for other files in the case of partial types.  In the
-            // event the other files aren't available, then partial-type information won't be correct.  That's ok though
-            // as this is just something that happens during solution load and will pass once that is over.  By using
-            // partial semantics, we can ensure we don't spend an inordinate amount of time computing and using full
-            // compilation data (like skeleton assemblies).
-            var document = snapshot.AsText().GetDocumentWithFrozenPartialSemantics(cancellationToken);
-            if (document == null)
-                return null;
+            var model = await ComputeModelAsync(textSnapshot, cancellationToken).ConfigureAwait(false);
+
+            await this.ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            // Now, enqueue work to select the right item in this new model.
+            StartSelectedItemUpdateTask();
+
+            return model;
 
-            var languageService = document.GetLanguageService<INavigationBarItemService>();
-            if (languageService != null)
+            static async Task<NavigationBarModel> ComputeModelAsync(ITextSnapshot textSnapshot, CancellationToken cancellationToken)
             {
-                // check whether we can re-use lastCompletedModel. otherwise, update lastCompletedModel here.
-                // the model should be only updated here
-                if (lastCompletedModel != null)
+                // When computing items just get the partial semantics workspace.  This will ensure we can get data for this
+                // file, and hopefully have enough loaded to get data for other files in the case of partial types.  In the
+                // event the other files aren't available, then partial-type information won't be correct.  That's ok though
+                // as this is just something that happens during solution load and will pass once that is over.  By using
+                // partial semantics, we can ensure we don't spend an inordinate amount of time computing and using full
+                // compilation data (like skeleton assemblies).
+                var document = textSnapshot.AsText().GetDocumentWithFrozenPartialSemantics(cancellationToken);
+                if (document == null)
+                    return null;
+
+                var itemService = document.GetLanguageService<INavigationBarItemService>();
+                if (itemService != null)
                 {
-                    var semanticVersion = await document.Project.GetDependentSemanticVersionAsync(CancellationToken.None).ConfigureAwait(false);
-                    if (lastCompletedModel.SemanticVersionStamp == semanticVersion && SpanStillValid(lastCompletedModel, snapshot, cancellationToken))
+                    using (Logger.LogBlock(FunctionId.NavigationBar_ComputeModelAsync, cancellationToken))
                     {
-                        // it looks like we can re-use previous model
-                        return lastCompletedModel;
+                        var items = await itemService.GetItemsAsync(document, textSnapshot, cancellationToken).ConfigureAwait(false);
+                        return new NavigationBarModel(items, itemService);
                     }
                 }
 
-                using (Logger.LogBlock(FunctionId.NavigationBar_ComputeModelAsync, cancellationToken))
-                {
-                    var items = await languageService.GetItemsAsync(document, snapshot, cancellationToken).ConfigureAwait(false);
-                    var version = await document.Project.GetDependentSemanticVersionAsync(cancellationToken).ConfigureAwait(false);
-                    return new NavigationBarModel(items, version, languageService);
-                }
+                return new NavigationBarModel(ImmutableArray<NavigationBarItem>.Empty, itemService: null);
             }
-
-            return new NavigationBarModel(ImmutableArray<NavigationBarItem>.Empty, new VersionStamp(), null);
         }
 
         /// <summary>
         /// Starts a new task to compute what item should be selected.
         /// </summary>
-        private void StartSelectedItemUpdateTask(int delay)
+        private void StartSelectedItemUpdateTask()
         {
-            AssertIsForeground();
-
-            var currentView = _presenter.TryGetCurrentView();
-            var subjectBufferCaretPosition = currentView?.GetCaretPoint(_subjectBuffer);
-            if (!subjectBufferCaretPosition.HasValue)
-                return;
-
-            // Cancel off any existing work
-            _selectedItemInfoTaskCancellationSource.Cancel();
-            _selectedItemInfoTaskCancellationSource = new CancellationTokenSource();
-            var cancellationToken = _selectedItemInfoTaskCancellationSource.Token;
-
-            var asyncToken = _asyncListener.BeginAsyncOperation(GetType().Name + ".StartSelectedItemUpdateTask");
-            var selectedItemInfoTask = DetermineSelectedItemInfoAsync(_modelTask, delay, subjectBufferCaretPosition.Value, cancellationToken);
-            selectedItemInfoTask.CompletesAsyncOperation(asyncToken);
+            // 'true' value is unused.  this just signals to the queue that we have work to do.
+            _selectItemQueue.AddWork();
         }
 
-        private async Task DetermineSelectedItemInfoAsync(
-            Task<NavigationBarModel> lastModelTask,
-            int delay,
-            SnapshotPoint caretPosition,
-            CancellationToken cancellationToken)
+        private async ValueTask SelectItemAsync(CancellationToken cancellationToken)
         {
-            // First wait the delay before doing any other work.  That way if we get canceled due to other events (like
-            // the user moving around), we don't end up doing anything, and the next task can take over.
-            await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
+            // Switch to the UI so we can determine where the user is.
+            await this.ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
-            var lastModel = await lastModelTask.ConfigureAwait(false);
-            if (cancellationToken.IsCancellationRequested)
+            var currentView = _presenter.TryGetCurrentView();
+            var caretPosition = currentView?.GetCaretPoint(_subjectBuffer);
+            if (!caretPosition.HasValue)
                 return;
 
-            var currentSelectedItem = ComputeSelectedTypeAndMember(lastModel, caretPosition, cancellationToken);
+            // Ensure the latest model is computed and grab it while on the UI thread.
+            var model = await _computeModelQueue.WaitUntilCurrentBatchCompletesAsync().ConfigureAwait(true);
 
-            await ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+            // Jump back to the BG to do any expensive work walking the entire model
+            await TaskScheduler.Default;
+
+            var currentSelectedItem = ComputeSelectedTypeAndMember(model, caretPosition.Value, cancellationToken);
 
-            AssertIsForeground();
+            // Finally, switch back to the UI to update our state and UI.
+            await ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             // Update the UI to show *just* the type/member that was selected.  We don't need it to know about all items
             // as the user can only see one at a time as they're editing in a document.  However, once we've done this,
             // store the full list of items as well so that if the user expands the dropdown, we can take all those
             // values and shove them in so it appears as if the lists were always fully realized.
-            _latestModelAndSelectedInfo_OnlyAccessOnUIThread = (lastModel, currentSelectedItem);
+            _latestModelAndSelectedInfo_OnlyAccessOnUIThread = (model, currentSelectedItem);
             PushSelectedItemsToPresenter(currentSelectedItem);
         }
 
@@ -247,55 +180,5 @@ private static (T item, bool gray) GetMatchingItem<T>(IEnumerable<T> items, Snap
                 return (itemToGray, gray: itemToGray != null);
             }
         }
-
-        private static bool SpanStillValid(NavigationBarModel model, ITextSnapshot snapshot, CancellationToken cancellationToken)
-        {
-            // even if semantic version is same, portion of text could have been copied & pasted with 
-            // exact same top level content.
-            // go through spans to see whether this happened.
-            // 
-            // paying cost of moving spans forward shouldn't be matter since we need to pay that 
-            // price soon or later to figure out selected item.
-            foreach (var type in model.Types)
-            {
-                if (!SpansStillValid(type, snapshot))
-                    return false;
-
-                foreach (var member in type.ChildItems)
-                {
-                    cancellationToken.ThrowIfCancellationRequested();
-
-                    if (!SpansStillValid(member, snapshot))
-                        return false;
-                }
-            }
-
-            return true;
-        }
-
-        private static bool SpansStillValid(NavigationBarItem item, ITextSnapshot snapshot)
-        {
-            if (item.NavigationTrackingSpan != null)
-            {
-                var currentSpan = item.NavigationTrackingSpan.GetSpan(snapshot);
-                if (currentSpan.IsEmpty)
-                    return false;
-            }
-
-            foreach (var span in item.TrackingSpans)
-            {
-                var currentSpan = span.GetSpan(snapshot);
-                if (currentSpan.IsEmpty)
-                    return false;
-            }
-
-            foreach (var childItem in item.ChildItems)
-            {
-                if (!SpansStillValid(childItem, snapshot))
-                    return false;
-            }
-
-            return true;
-        }
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarModel.cs b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarModel.cs
index 99faf5fad32cd..71173991e818d 100644
--- a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarModel.cs
+++ b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarModel.cs
@@ -3,27 +3,17 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.NavigationBar
 {
     internal sealed class NavigationBarModel
     {
         public ImmutableArray<NavigationBarItem> Types { get; }
-
-        /// <summary>
-        /// The VersionStamp of the project when this model was computed.
-        /// </summary>
-        public VersionStamp SemanticVersionStamp { get; }
-
         public INavigationBarItemService ItemService { get; }
 
-        public NavigationBarModel(ImmutableArray<NavigationBarItem> types, VersionStamp semanticVersionStamp, INavigationBarItemService itemService)
+        public NavigationBarModel(ImmutableArray<NavigationBarItem> types, INavigationBarItemService itemService)
         {
-            Contract.ThrowIfNull(types);
-
             this.Types = types;
-            this.SemanticVersionStamp = semanticVersionStamp;
             this.ItemService = itemService;
         }
     }
diff --git a/src/EditorFeatures/Core/Implementation/Structure/AbstractStructureTaggerProvider.cs b/src/EditorFeatures/Core/Implementation/Structure/AbstractStructureTaggerProvider.cs
index a7c730d93ee17..0f0fc8d096f81 100644
--- a/src/EditorFeatures/Core/Implementation/Structure/AbstractStructureTaggerProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/Structure/AbstractStructureTaggerProvider.cs
@@ -202,6 +202,7 @@ private static ImmutableArray<BlockSpan> GetMultiLineRegions(
                             {
                             }
                         }
+
                         continue;
                     }
 
diff --git a/src/EditorFeatures/Core/Implementation/Structure/StructureTag.cs b/src/EditorFeatures/Core/Implementation/Structure/StructureTag.cs
index 75504548dbd4a..527fc7d0c5fe4 100644
--- a/src/EditorFeatures/Core/Implementation/Structure/StructureTag.cs
+++ b/src/EditorFeatures/Core/Implementation/Structure/StructureTag.cs
@@ -80,6 +80,7 @@ private static string ConvertType(string type)
                 BlockTypes.Loop => PredefinedStructureTagTypes.Loop,
                 BlockTypes.Member => PredefinedStructureTagTypes.Member,
                 BlockTypes.Namespace => PredefinedStructureTagTypes.Namespace,
+                BlockTypes.Nonstructural => PredefinedStructureTagTypes.Nonstructural,
                 BlockTypes.PreprocessorRegion => PredefinedStructureTagTypes.PreprocessorRegion,
                 BlockTypes.Statement => PredefinedStructureTagTypes.Statement,
                 BlockTypes.Type => PredefinedStructureTagTypes.Type,
diff --git a/src/EditorFeatures/Core/Implementation/Workspaces/ProjectCacheServiceFactory.cs b/src/EditorFeatures/Core/Implementation/Workspaces/ProjectCacheServiceFactory.cs
index aeff2305ff6a4..dfce03777c761 100644
--- a/src/EditorFeatures/Core/Implementation/Workspaces/ProjectCacheServiceFactory.cs
+++ b/src/EditorFeatures/Core/Implementation/Workspaces/ProjectCacheServiceFactory.cs
@@ -15,7 +15,7 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.Workspaces
     [Shared]
     internal partial class ProjectCacheHostServiceFactory : IWorkspaceServiceFactory
     {
-        private const int ImplicitCacheTimeoutInMS = 10000;
+        private static readonly TimeSpan s_implicitCacheTimeout = TimeSpan.FromMilliseconds(10000);
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
@@ -30,7 +30,7 @@ public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
                 return new ProjectCacheService(workspaceServices.Workspace);
             }
 
-            var service = new ProjectCacheService(workspaceServices.Workspace, ImplicitCacheTimeoutInMS);
+            var service = new ProjectCacheService(workspaceServices.Workspace, s_implicitCacheTimeout);
 
             // Also clear the cache when the solution is cleared or removed.
             workspaceServices.Workspace.WorkspaceChanged += (s, e) =>
diff --git a/src/EditorFeatures/Core/InheritanceMargin/AbstractInheritanceMarginService.cs b/src/EditorFeatures/Core/InheritanceMargin/AbstractInheritanceMarginService.cs
index b48d1535a71f8..19ccfd66c8666 100644
--- a/src/EditorFeatures/Core/InheritanceMargin/AbstractInheritanceMarginService.cs
+++ b/src/EditorFeatures/Core/InheritanceMargin/AbstractInheritanceMarginService.cs
@@ -87,13 +87,16 @@ public async ValueTask<ImmutableArray<InheritanceMarginItem>> GetInheritanceMemb
 
         private static bool CanHaveInheritanceTarget(ISymbol symbol)
         {
-            if (symbol.IsStatic)
+            if (symbol is INamedTypeSymbol namedType)
             {
-                return false;
+                return !symbol.IsStatic && namedType.TypeKind is TypeKind.Interface or TypeKind.Class or TypeKind.Struct;
             }
 
-            if (symbol is INamedTypeSymbol or IEventSymbol or IPropertySymbol
-                or IMethodSymbol { MethodKind: MethodKind.Ordinary or MethodKind.ExplicitInterfaceImplementation })
+            if (symbol is IEventSymbol or IPropertySymbol
+                or IMethodSymbol
+                {
+                    MethodKind: MethodKind.Ordinary or MethodKind.ExplicitInterfaceImplementation or MethodKind.UserDefinedOperator or MethodKind.Conversion
+                })
             {
                 return true;
             }
diff --git a/src/EditorFeatures/Core/InheritanceMargin/InheritanceMarginServiceHelpers.cs b/src/EditorFeatures/Core/InheritanceMargin/InheritanceMarginServiceHelpers.cs
index 02279bca1ab74..875b49ff4f9bb 100644
--- a/src/EditorFeatures/Core/InheritanceMargin/InheritanceMarginServiceHelpers.cs
+++ b/src/EditorFeatures/Core/InheritanceMargin/InheritanceMarginServiceHelpers.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -76,6 +77,7 @@ private static async ValueTask<ImmutableArray<SerializableInheritanceMarginItem>
             foreach (var (symbolKey, lineNumber) in symbolKeyAndLineNumbers)
             {
                 var symbol = symbolKey.Resolve(compilation, cancellationToken: cancellationToken).Symbol;
+
                 if (symbol is INamedTypeSymbol namedTypeSymbol)
                 {
                     await AddInheritanceMemberItemsForNamedTypeAsync(solution, namedTypeSymbol, lineNumber, builder, cancellationToken).ConfigureAwait(false);
@@ -83,7 +85,7 @@ private static async ValueTask<ImmutableArray<SerializableInheritanceMarginItem>
 
                 if (symbol is IEventSymbol or IPropertySymbol or IMethodSymbol)
                 {
-                    await AddInheritanceMemberItemsForTypeMembersAsync(solution, symbol, lineNumber, builder, cancellationToken).ConfigureAwait(false);
+                    await AddInheritanceMemberItemsForMembersAsync(solution, symbol, lineNumber, builder, cancellationToken).ConfigureAwait(false);
                 }
             }
 
@@ -124,68 +126,92 @@ private static async ValueTask AddInheritanceMemberItemsForNamedTypeAsync(
 
             if (baseSymbols.Any() || derivedSymbols.Any())
             {
-                var item = await CreateInheritanceMemberItemAsync(
-                    solution,
-                    memberSymbol,
-                    lineNumber,
-                    baseSymbols: baseSymbols.CastArray<ISymbol>(),
-                    derivedTypesSymbols: derivedSymbols.CastArray<ISymbol>(),
-                    cancellationToken).ConfigureAwait(false);
-                builder.AddIfNotNull(item);
+                if (memberSymbol.TypeKind == TypeKind.Interface)
+                {
+                    var item = await CreateInheritanceMemberItemForInterfaceAsync(
+                        solution,
+                        memberSymbol,
+                        lineNumber,
+                        baseSymbols: baseSymbols.CastArray<ISymbol>(),
+                        derivedTypesSymbols: derivedSymbols.CastArray<ISymbol>(),
+                        cancellationToken).ConfigureAwait(false);
+                    builder.AddIfNotNull(item);
+                }
+                else
+                {
+                    Debug.Assert(memberSymbol.TypeKind is TypeKind.Class or TypeKind.Struct);
+                    var item = await CreateInheritanceItemForClassAndStructureAsync(
+                        solution,
+                        memberSymbol,
+                        lineNumber,
+                        baseSymbols: baseSymbols.CastArray<ISymbol>(),
+                        derivedTypesSymbols: derivedSymbols.CastArray<ISymbol>(),
+                        cancellationToken).ConfigureAwait(false);
+                    builder.AddIfNotNull(item);
+                }
             }
         }
 
-        private static async ValueTask AddInheritanceMemberItemsForTypeMembersAsync(
+        private static async ValueTask AddInheritanceMemberItemsForMembersAsync(
             Solution solution,
             ISymbol memberSymbol,
             int lineNumber,
             ArrayBuilder<SerializableInheritanceMarginItem> builder,
             CancellationToken cancellationToken)
         {
-            // For a given member symbol (method, property and event), its base and derived symbols are classified into 4 cases.
-            // The mapping between images
-            // Implemented : I↓
-            // Implementing : I↑
-            // Overridden: O↓
-            // Overriding: O↑
-
-            // Go down the inheritance chain to find all the overrides targets.
-            var allOverriddenSymbols = await SymbolFinder.FindOverridesArrayAsync(memberSymbol, solution, cancellationToken: cancellationToken).ConfigureAwait(false);
+            if (memberSymbol.ContainingSymbol.IsInterfaceType())
+            {
+                // Go down the inheritance chain to find all the implementing targets.
+                var allImplementingSymbols = await GetImplementingSymbolsForTypeMemberAsync(solution, memberSymbol, cancellationToken).ConfigureAwait(false);
 
-            // Go up the inheritance chain to find all overriding targets
-            var overridingSymbols = GetOverridingSymbols(memberSymbol);
+                // For all implementing symbols, make sure it is in source.
+                // For example, if the user is viewing IEnumerable from metadata,
+                // then don't show the derived overriden & implemented types in System.Collections
+                var implementingSymbols = allImplementingSymbols.WhereAsArray(symbol => symbol.Locations.Any(l => l.IsInSource));
 
-            // Go up the inheritance chain to find all the implemented targets.
-            var implementingSymbols = GetImplementingSymbolsForTypeMember(memberSymbol, overridingSymbols);
+                if (implementingSymbols.Any())
+                {
+                    var item = await CreateInheritanceMemberItemForInterfaceMemberAsync(solution,
+                        memberSymbol,
+                        lineNumber,
+                        implementingMembers: implementingSymbols,
+                        cancellationToken).ConfigureAwait(false);
+                    builder.AddIfNotNull(item);
+                }
+            }
+            else
+            {
+                // Go down the inheritance chain to find all the overriding targets.
+                var allOverridingSymbols = await SymbolFinder.FindOverridesArrayAsync(memberSymbol, solution, cancellationToken: cancellationToken).ConfigureAwait(false);
 
-            // Go down the inheritance chain to find all the implementing targets.
-            var allImplementedSymbols = await GetImplementedSymbolsForTypeMemberAsync(solution, memberSymbol, cancellationToken).ConfigureAwait(false);
+                // Go up the inheritance chain to find all overridden targets
+                var overriddenSymbols = GetOverriddenSymbols(memberSymbol);
 
-            // For all overriden & implemented symbols, make sure it is in source.
-            // For example, if the user is viewing System.Threading.SynchronizationContext from metadata,
-            // then don't show the derived overriden & implemented method in the default implementation for System.Threading.SynchronizationContext in metadata
-            var overriddenSymbols = allOverriddenSymbols.WhereAsArray(symbol => symbol.Locations.Any(l => l.IsInSource));
-            var implementedSymbols = allImplementedSymbols.WhereAsArray(symbol => symbol.Locations.Any(l => l.IsInSource));
+                // Go up the inheritance chain to find all the implemented targets.
+                var implementedSymbols = GetImplementedSymbolsForTypeMember(memberSymbol, overriddenSymbols);
 
-            if (overriddenSymbols.Any() || overridingSymbols.Any() || implementingSymbols.Any() || implementedSymbols.Any())
-            {
-                var item = await CreateInheritanceMemberInfoForMemberAsync(
-                    solution,
-                    memberSymbol,
-                    lineNumber,
-                    implementingMembers: implementingSymbols,
-                    implementedMembers: implementedSymbols,
-                    overridenMembers: overriddenSymbols,
-                    overridingMembers: overridingSymbols,
-                    cancellationToken).ConfigureAwait(false);
+                // For all overriding symbols, make sure it is in source.
+                // For example, if the user is viewing System.Threading.SynchronizationContext from metadata,
+                // then don't show the derived overriden & implemented method in the default implementation for System.Threading.SynchronizationContext in metadata
+                var overridingSymbols = allOverridingSymbols.WhereAsArray(symbol => symbol.Locations.Any(l => l.IsInSource));
 
-                builder.AddIfNotNull(item);
+                if (overridingSymbols.Any() || overriddenSymbols.Any() || implementedSymbols.Any())
+                {
+                    var item = await CreateInheritanceMemberItemForClassOrStructMemberAsync(solution,
+                        memberSymbol,
+                        lineNumber,
+                        implementedMembers: implementedSymbols,
+                        overridingMembers: overridingSymbols,
+                        overriddenMembers: overriddenSymbols,
+                        cancellationToken).ConfigureAwait(false);
+                    builder.AddIfNotNull(item);
+                }
             }
         }
 
-        private static async ValueTask<SerializableInheritanceMarginItem> CreateInheritanceMemberItemAsync(
+        private static async ValueTask<SerializableInheritanceMarginItem> CreateInheritanceMemberItemForInterfaceAsync(
             Solution solution,
-            INamedTypeSymbol memberSymbol,
+            INamedTypeSymbol interfaceSymbol,
             int lineNumber,
             ImmutableArray<ISymbol> baseSymbols,
             ImmutableArray<ISymbol> derivedTypesSymbols,
@@ -194,89 +220,158 @@ private static async ValueTask<SerializableInheritanceMarginItem> CreateInherita
             var baseSymbolItems = await baseSymbols
                 .SelectAsArray(symbol => symbol.OriginalDefinition)
                 .Distinct()
-                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(solution, symbol, InheritanceRelationship.Implementing, cancellationToken), cancellationToken)
+                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(
+                    solution,
+                    symbol,
+                    InheritanceRelationship.InheritedInterface,
+                    cancellationToken), cancellationToken)
                 .ConfigureAwait(false);
 
             var derivedTypeItems = await derivedTypesSymbols
                 .SelectAsArray(symbol => symbol.OriginalDefinition)
                 .Distinct()
-                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(solution, symbol, InheritanceRelationship.Implemented, cancellationToken), cancellationToken)
+                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(solution,
+                    symbol,
+                    InheritanceRelationship.ImplementingType,
+                    cancellationToken), cancellationToken)
                 .ConfigureAwait(false);
 
             return new SerializableInheritanceMarginItem(
                 lineNumber,
-                FindUsagesHelpers.GetDisplayParts(memberSymbol),
-                memberSymbol.GetGlyph(),
+                FindUsagesHelpers.GetDisplayParts(interfaceSymbol),
+                interfaceSymbol.GetGlyph(),
                 baseSymbolItems.Concat(derivedTypeItems));
         }
 
-        private static async ValueTask<SerializableInheritanceTargetItem> CreateInheritanceItemAsync(
+        private static async ValueTask<SerializableInheritanceMarginItem> CreateInheritanceMemberItemForInterfaceMemberAsync(
             Solution solution,
-            ISymbol targetSymbol,
-            InheritanceRelationship inheritanceRelationship,
+            ISymbol memberSymbol,
+            int lineNumber,
+            ImmutableArray<ISymbol> implementingMembers,
             CancellationToken cancellationToken)
         {
-            var symbolInSource = await SymbolFinder.FindSourceDefinitionAsync(targetSymbol, solution, cancellationToken).ConfigureAwait(false);
-            targetSymbol = symbolInSource ?? targetSymbol;
+            var implementedMemberItems = await implementingMembers
+                .SelectAsArray(symbol => symbol.OriginalDefinition)
+                .Distinct()
+                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(
+                    solution,
+                    symbol,
+                    InheritanceRelationship.ImplementingMember,
+                    cancellationToken), cancellationToken).ConfigureAwait(false);
 
-            // Right now the targets are not shown in a classified way.
-            var definition = await targetSymbol.ToNonClassifiedDefinitionItemAsync(
-                solution,
-                includeHiddenLocations: false,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+            return new SerializableInheritanceMarginItem(
+                lineNumber,
+                FindUsagesHelpers.GetDisplayParts(memberSymbol),
+                memberSymbol.GetGlyph(),
+                implementedMemberItems);
+        }
 
-            var displayName = targetSymbol.ToDisplayString(s_displayFormat);
+        private static async ValueTask<SerializableInheritanceMarginItem> CreateInheritanceItemForClassAndStructureAsync(
+            Solution solution,
+            INamedTypeSymbol memberSymbol,
+            int lineNumber,
+            ImmutableArray<ISymbol> baseSymbols,
+            ImmutableArray<ISymbol> derivedTypesSymbols,
+            CancellationToken cancellationToken)
+        {
+            // If the target is an interface, it would be shown as 'Inherited interface',
+            // and if it is an class/struct, it whould be shown as 'Base Type'
+            var baseSymbolItems = await baseSymbols
+                .SelectAsArray(symbol => symbol.OriginalDefinition)
+                .Distinct()
+                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(
+                    solution,
+                    symbol,
+                    symbol.IsInterfaceType() ? InheritanceRelationship.ImplementedInterface : InheritanceRelationship.BaseType,
+                    cancellationToken), cancellationToken).ConfigureAwait(false);
 
-            return new SerializableInheritanceTargetItem(
-                inheritanceRelationship,
-                // Id is used by FAR service for caching, it is not used in inheritance margin
-                SerializableDefinitionItem.Dehydrate(id: 0, definition),
-                targetSymbol.GetGlyph(),
-                displayName);
+            var derivedTypeItems = await derivedTypesSymbols
+                .SelectAsArray(symbol => symbol.OriginalDefinition)
+                .Distinct()
+                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(solution,
+                    symbol,
+                    InheritanceRelationship.DerivedType,
+                    cancellationToken), cancellationToken)
+                .ConfigureAwait(false);
+
+            return new SerializableInheritanceMarginItem(
+                lineNumber,
+                FindUsagesHelpers.GetDisplayParts(memberSymbol),
+                memberSymbol.GetGlyph(),
+                baseSymbolItems.Concat(derivedTypeItems));
         }
 
-        private static async ValueTask<SerializableInheritanceMarginItem> CreateInheritanceMemberInfoForMemberAsync(
+        private static async ValueTask<SerializableInheritanceMarginItem> CreateInheritanceMemberItemForClassOrStructMemberAsync(
             Solution solution,
             ISymbol memberSymbol,
             int lineNumber,
-            ImmutableArray<ISymbol> implementingMembers,
             ImmutableArray<ISymbol> implementedMembers,
-            ImmutableArray<ISymbol> overridenMembers,
             ImmutableArray<ISymbol> overridingMembers,
+            ImmutableArray<ISymbol> overriddenMembers,
             CancellationToken cancellationToken)
         {
-            var implementingMemberItems = await implementingMembers
-                .SelectAsArray(symbol => symbol.OriginalDefinition)
-                .Distinct()
-                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(solution, symbol, InheritanceRelationship.Implementing, cancellationToken), cancellationToken).ConfigureAwait(false);
-
             var implementedMemberItems = await implementedMembers
                 .SelectAsArray(symbol => symbol.OriginalDefinition)
                 .Distinct()
-                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(solution, symbol, InheritanceRelationship.Implemented, cancellationToken), cancellationToken).ConfigureAwait(false);
+                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(
+                    solution,
+                    symbol,
+                    InheritanceRelationship.ImplementedMember,
+                    cancellationToken), cancellationToken).ConfigureAwait(false);
 
-            var overridenMemberItems = await overridenMembers
+            var overridenMemberItems = await overriddenMembers
                 .SelectAsArray(symbol => symbol.OriginalDefinition)
                 .Distinct()
-                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(solution, symbol, InheritanceRelationship.Overridden, cancellationToken), cancellationToken).ConfigureAwait(false);
+                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(
+                    solution,
+                    symbol,
+                    InheritanceRelationship.OverriddenMember,
+                    cancellationToken), cancellationToken).ConfigureAwait(false);
 
             var overridingMemberItems = await overridingMembers
                 .SelectAsArray(symbol => symbol.OriginalDefinition)
                 .Distinct()
-                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(solution, symbol, InheritanceRelationship.Overriding, cancellationToken), cancellationToken).ConfigureAwait(false);
+                .SelectAsArrayAsync((symbol, _) => CreateInheritanceItemAsync(
+                    solution,
+                    symbol,
+                    InheritanceRelationship.OverridingMember,
+                    cancellationToken), cancellationToken).ConfigureAwait(false);
 
             return new SerializableInheritanceMarginItem(
                 lineNumber,
                 FindUsagesHelpers.GetDisplayParts(memberSymbol),
                 memberSymbol.GetGlyph(),
-                implementingMemberItems.Concat(implementedMemberItems)
-                    .Concat(overridenMemberItems)
-                    .Concat(overridingMemberItems));
+                implementedMemberItems.Concat(overridenMemberItems).Concat(overridingMemberItems));
+        }
+
+        private static async ValueTask<SerializableInheritanceTargetItem> CreateInheritanceItemAsync(
+            Solution solution,
+            ISymbol targetSymbol,
+            InheritanceRelationship inheritanceRelationship,
+            CancellationToken cancellationToken)
+        {
+            var symbolInSource = await SymbolFinder.FindSourceDefinitionAsync(targetSymbol, solution, cancellationToken).ConfigureAwait(false);
+            targetSymbol = symbolInSource ?? targetSymbol;
+
+            // Right now the targets are not shown in a classified way.
+            var definition = await targetSymbol.ToNonClassifiedDefinitionItemAsync(
+                solution,
+                includeHiddenLocations: false,
+                cancellationToken: cancellationToken).ConfigureAwait(false);
+
+            var displayName = targetSymbol.ToDisplayString(s_displayFormat);
+
+            return new SerializableInheritanceTargetItem(
+                inheritanceRelationship,
+                // Id is used by FAR service for caching, it is not used in inheritance margin
+                SerializableDefinitionItem.Dehydrate(id: 0, definition),
+                targetSymbol.GetGlyph(),
+                displayName);
         }
 
-        private static ImmutableArray<ISymbol> GetImplementingSymbolsForTypeMember(
+        private static ImmutableArray<ISymbol> GetImplementedSymbolsForTypeMember(
             ISymbol memberSymbol,
-            ImmutableArray<ISymbol> overridingSymbols)
+            ImmutableArray<ISymbol> overriddenSymbols)
         {
             if (memberSymbol is IMethodSymbol or IEventSymbol or IPropertySymbol)
             {
@@ -286,13 +381,13 @@ private static ImmutableArray<ISymbol> GetImplementingSymbolsForTypeMember(
                 var directImplementingSymbols = memberSymbol.ExplicitOrImplicitInterfaceImplementations();
                 builder.AddRange(directImplementingSymbols);
 
-                // 2. Also add the direct implementing symbols for the overriding symbols.
+                // 2. Also add the direct implementing symbols for the overridden symbols.
                 // For example:
                 // interface IBar { void Foo(); }
                 // class Bar : IBar { public override void Foo() { } }
                 // class Bar2 : Bar { public override void Foo() { } }
                 // For 'Bar2.Foo()',  we need to find 'IBar.Foo()'
-                foreach (var symbol in overridingSymbols)
+                foreach (var symbol in overriddenSymbols)
                 {
                     builder.AddRange(symbol.ExplicitOrImplicitInterfaceImplementations());
                 }
@@ -304,20 +399,15 @@ private static ImmutableArray<ISymbol> GetImplementingSymbolsForTypeMember(
         }
 
         /// <summary>
-        /// For the <param name="memberSymbol"/>, get all the implemented symbols.
-        /// Table for the mapping between images and inheritanceRelationship
-        /// Implemented : I↓
-        /// Implementing : I↑
-        /// Overridden: O↓
-        /// Overriding: O↑
+        /// For the <param name="memberSymbol"/>, get all the implementing symbols.
         /// </summary>
-        private static async Task<ImmutableArray<ISymbol>> GetImplementedSymbolsForTypeMemberAsync(
+        private static async Task<ImmutableArray<ISymbol>> GetImplementingSymbolsForTypeMemberAsync(
             Solution solution,
             ISymbol memberSymbol,
             CancellationToken cancellationToken)
         {
             if (memberSymbol is IMethodSymbol or IEventSymbol or IPropertySymbol
-                 && memberSymbol.ContainingSymbol.IsInterfaceType())
+                && memberSymbol.ContainingSymbol.IsInterfaceType())
             {
                 using var _ = ArrayBuilder<ISymbol>.GetInstance(out var builder);
                 // 1. Find all direct implementations for this member
@@ -344,14 +434,9 @@ private static async Task<ImmutableArray<ISymbol>> GetImplementedSymbolsForTypeM
         }
 
         /// <summary>
-        /// Get members overriding the <param name="memberSymbol"/>
-        /// Table for the mapping between images and inheritanceRelationship
-        /// Implemented : I↓
-        /// Implementing : I↑
-        /// Overridden: O↓
-        /// Overriding: O↑
+        /// Get overridden members the <param name="memberSymbol"/>.
         /// </summary>
-        private static ImmutableArray<ISymbol> GetOverridingSymbols(ISymbol memberSymbol)
+        private static ImmutableArray<ISymbol> GetOverriddenSymbols(ISymbol memberSymbol)
         {
             if (memberSymbol is INamedTypeSymbol)
             {
@@ -360,11 +445,11 @@ private static ImmutableArray<ISymbol> GetOverridingSymbols(ISymbol memberSymbol
             else
             {
                 using var _ = ArrayBuilder<ISymbol>.GetInstance(out var builder);
-                for (var overridenMember = memberSymbol.GetOverriddenMember();
-                    overridenMember != null;
-                    overridenMember = overridenMember.GetOverriddenMember())
+                for (var overriddenMember = memberSymbol.GetOverriddenMember();
+                    overriddenMember != null;
+                    overriddenMember = overriddenMember.GetOverriddenMember())
                 {
-                    builder.Add(overridenMember.OriginalDefinition);
+                    builder.Add(overriddenMember.OriginalDefinition);
                 }
 
                 return builder.ToImmutableArray();
diff --git a/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj b/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj
index d75f775bae394..134ee1de0e3d7 100644
--- a/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj
@@ -7,7 +7,7 @@
     <TargetFrameworks>netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>$(DefineConstants);EDITOR_FEATURES</DefineConstants>
-    <ApplyNgenOptimization>partial</ApplyNgenOptimization>
+    <ApplyNgenOptimization Condition="'$(TargetFramework)' == 'netstandard2.0'">partial</ApplyNgenOptimization>
 
     <!-- NuGet -->
     <PackageId>Microsoft.CodeAnalysis.EditorFeatures.Common</PackageId>
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs b/src/EditorFeatures/Core/ReferenceHighlighting/NavigateToHighlightReferenceCommandHandler.cs
similarity index 100%
rename from src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/NavigateToHighlightReferenceCommandHandler.cs
diff --git a/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs b/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs
index beaeec8532aae..039aa8727007e 100644
--- a/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs
+++ b/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs
@@ -78,16 +78,19 @@ internal static class FeatureOnOffOptions
             nameof(FeatureOnOffOptions), nameof(OfferRemoveUnusedReferences), defaultValue: true,
             storageLocations: new RoamingProfileStorageLocation($"TextEditor.{nameof(OfferRemoveUnusedReferences)}"));
 
-        public static readonly PerLanguageOption2<bool> ShowInheritanceMargin =
+        public static readonly PerLanguageOption2<bool?> ShowInheritanceMargin =
             new(nameof(FeatureOnOffOptions),
                 nameof(ShowInheritanceMargin),
-                defaultValue: false,
+                defaultValue: null,
                 new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.ShowInheritanceMargin"));
 
         public static readonly Option2<bool> AutomaticallyCompleteStatementOnSemicolon = new(
             nameof(FeatureOnOffOptions), nameof(AutomaticallyCompleteStatementOnSemicolon), defaultValue: true,
             storageLocations: new RoamingProfileStorageLocation($"TextEditor.{nameof(AutomaticallyCompleteStatementOnSemicolon)}"));
 
+        public static readonly Option2<bool> SkipAnalyzersForImplicitlyTriggeredBuilds = new(
+            nameof(FeatureOnOffOptions), nameof(SkipAnalyzersForImplicitlyTriggeredBuilds), defaultValue: true,
+            storageLocations: new RoamingProfileStorageLocation($"TextEditor.{nameof(SkipAnalyzersForImplicitlyTriggeredBuilds)}"));
     }
 
     [ExportOptionProvider, Shared]
@@ -117,6 +120,7 @@ public FeatureOnOffOptionsProvider()
             FeatureOnOffOptions.AddImportsOnPaste,
             FeatureOnOffOptions.OfferRemoveUnusedReferences,
             FeatureOnOffOptions.ShowInheritanceMargin,
-            FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon);
+            FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon,
+            FeatureOnOffOptions.SkipAnalyzersForImplicitlyTriggeredBuilds);
     }
 }
diff --git a/src/EditorFeatures/Core/Shared/Preview/PreviewSolutionCrawlerRegistrationService.cs b/src/EditorFeatures/Core/Shared/Preview/PreviewSolutionCrawlerRegistrationService.cs
index 0b5cf858ab7e5..ec124733a96ec 100644
--- a/src/EditorFeatures/Core/Shared/Preview/PreviewSolutionCrawlerRegistrationService.cs
+++ b/src/EditorFeatures/Core/Shared/Preview/PreviewSolutionCrawlerRegistrationService.cs
@@ -72,7 +72,7 @@ public void Register(Workspace workspace)
 
             private async Task AnalyzeAsync()
             {
-                var workerBackOffTimeSpanInMS = _workspace.Options.GetOption(InternalSolutionCrawlerOptions.PreviewBackOffTimeSpanInMS);
+                var workerBackOffTimeSpan = InternalSolutionCrawlerOptions.PreviewBackOffTimeSpan;
                 var incrementalAnalyzer = _owner._analyzerService.CreateIncrementalAnalyzer(_workspace);
 
                 var solution = _workspace.CurrentSolution;
@@ -89,7 +89,7 @@ private async Task AnalyzeAsync()
                         }
 
                         // delay analyzing
-                        await Task.Delay(workerBackOffTimeSpanInMS, _source.Token).ConfigureAwait(false);
+                        await _owner._listener.Delay(workerBackOffTimeSpan, _source.Token).ConfigureAwait(false);
 
                         // do actual analysis
                         if (textDocument is Document document)
diff --git a/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.WorkspaceChangedEventSource.cs b/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.WorkspaceChangedEventSource.cs
index 63dca1866fc32..e00a949d931f0 100644
--- a/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.WorkspaceChangedEventSource.cs
+++ b/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.WorkspaceChangedEventSource.cs
@@ -15,7 +15,7 @@ internal partial class TaggerEventSources
     {
         private class WorkspaceChangedEventSource : AbstractWorkspaceTrackingTaggerEventSource
         {
-            private readonly AsyncBatchingDelay _asyncDelay;
+            private readonly AsyncBatchingWorkQueue _asyncDelay;
 
             public WorkspaceChangedEventSource(
                 ITextBuffer subjectBuffer,
@@ -24,12 +24,12 @@ public WorkspaceChangedEventSource(
             {
                 // That will ensure that even if we get a flurry of workspace events that we
                 // only process a tag change once.
-                _asyncDelay = new AsyncBatchingDelay(
+                _asyncDelay = new AsyncBatchingWorkQueue(
                     TimeSpan.FromMilliseconds(250),
-                    processAsync: cancellationToken =>
+                    processBatchAsync: cancellationToken =>
                     {
                         RaiseChanged();
-                        return Task.CompletedTask;
+                        return ValueTaskFactory.CompletedTask;
                     },
                     asyncListener,
                     CancellationToken.None);
@@ -48,7 +48,7 @@ protected override void DisconnectFromWorkspace(Workspace workspace)
             }
 
             private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs eventArgs)
-                => _asyncDelay.RequeueWork();
+                => _asyncDelay.AddWork();
         }
     }
 }
diff --git a/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSourceState.cs b/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSourceState.cs
index c13b91768cc9a..1327e55cd7b6e 100644
--- a/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSourceState.cs
+++ b/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSourceState.cs
@@ -62,6 +62,7 @@ public CancellationToken GetCancellationToken(bool initialTags)
                 public void EnqueueWork(
                     Func<Task> workAsync,
                     TaggerDelay delay,
+                    IExpeditableDelaySource delaySource,
                     IAsyncToken asyncToken,
                     CancellationToken cancellationToken)
                 {
@@ -70,7 +71,8 @@ public void EnqueueWork(
                         _eventWorkQueue = _eventWorkQueue.ContinueWithAfterDelayFromAsync(
                             _ => workAsync(),
                             cancellationToken,
-                            (int)delay.ComputeTimeDelay().TotalMilliseconds,
+                            delay.ComputeTimeDelay(),
+                            delaySource,
                             TaskContinuationOptions.None,
                             TaskScheduler.Default).CompletesAsyncOperation(asyncToken);
                     }
diff --git a/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_ProduceTags.cs b/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_ProduceTags.cs
index b871b598e8846..7381dad55cd5c 100644
--- a/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_ProduceTags.cs
+++ b/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_ProduceTags.cs
@@ -188,7 +188,7 @@ private void EnqueueWork(bool initialTags)
                 {
                     await this.ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
                     await RecomputeTagsForegroundAsync(initialTags, cancellationToken).ConfigureAwait(false);
-                }, _dataSource.EventChangeDelay, _asyncListener.BeginAsyncOperation(nameof(EnqueueWork)), cancellationToken);
+                }, _dataSource.EventChangeDelay, _asyncListener, _asyncListener.BeginAsyncOperation(nameof(EnqueueWork)), cancellationToken);
             }
 
             /// <summary>
diff --git a/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_TagsChanged.cs b/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_TagsChanged.cs
index 3437033b7809f..a7cb189fe08ba 100644
--- a/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_TagsChanged.cs
+++ b/src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_TagsChanged.cs
@@ -42,12 +42,12 @@ private void OnTagsChangedForBuffer(
                 }
             }
 
-            private Task ProcessTagsChangedAsync(
+            private ValueTask ProcessTagsChangedAsync(
                 ImmutableArray<NormalizedSnapshotSpanCollection> snapshotSpans, CancellationToken cancellationToken)
             {
                 var tagsChanged = this.TagsChanged;
                 if (tagsChanged == null)
-                    return Task.CompletedTask;
+                    return ValueTaskFactory.CompletedTask;
 
                 foreach (var collection in snapshotSpans)
                 {
@@ -65,7 +65,7 @@ private Task ProcessTagsChangedAsync(
                         tagsChanged(this, new SnapshotSpanEventArgs(span));
                 }
 
-                return Task.CompletedTask;
+                return ValueTaskFactory.CompletedTask;
             }
         }
     }
diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs
index 6ac0276e90786..a53c5d8cfd2c0 100644
--- a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs
+++ b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs
@@ -13,6 +13,9 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Testing.Verifiers;
 using Xunit;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.Text;
 
 #if !CODE_STYLE
 using Roslyn.Utilities;
@@ -26,6 +29,8 @@ public static partial class CSharpCodeFixVerifier<TAnalyzer, TCodeFix>
     {
         public class Test : CSharpCodeFixTest<TAnalyzer, TCodeFix, XUnitVerifier>
         {
+            private readonly SharedVerifierState _sharedState;
+
             static Test()
             {
                 // If we have outdated defaults from the host unit test application targeting an older .NET Framework, use more
@@ -42,6 +47,8 @@ static Test()
 
             public Test()
             {
+                _sharedState = new SharedVerifierState(this, DefaultFileExt);
+
                 MarkupOptions = Testing.MarkupOptions.UseFirstDescriptor;
 
                 SolutionTransforms.Add((solution, projectId) =>
@@ -53,26 +60,6 @@ public Test()
                     compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(compilationOptions.SpecificDiagnosticOptions.SetItems(CSharpVerifierHelper.NullableWarnings));
                     solution = solution.WithProjectCompilationOptions(projectId, compilationOptions);
 
-                    var (analyzerConfigSource, remainingOptions) = CodeFixVerifierHelper.ConvertOptionsToAnalyzerConfig(DefaultFileExt, EditorConfig, Options);
-                    if (analyzerConfigSource is object)
-                    {
-                        foreach (var id in solution.ProjectIds)
-                        {
-                            var documentId = DocumentId.CreateNewId(id, ".editorconfig");
-                            solution = solution.AddAnalyzerConfigDocument(documentId, ".editorconfig", analyzerConfigSource, filePath: "/.editorconfig");
-                        }
-                    }
-
-#if !CODE_STYLE
-                    var options = solution.Options;
-                    foreach (var (key, value) in remainingOptions)
-                    {
-                        options = options.WithChangedOption(key, value);
-                    }
-
-                    solution = solution.WithOptions(options);
-#endif
-
                     return solution;
                 });
             }
@@ -83,24 +70,29 @@ public Test()
             /// </summary>
             public LanguageVersion LanguageVersion { get; set; } = LanguageVersion.CSharp8;
 
-            /// <summary>
-            /// Gets a collection of options to apply to <see cref="Solution.Options"/> for testing. Values may be added
-            /// using a collection initializer.
-            /// </summary>
-            internal OptionsCollection Options { get; } = new OptionsCollection(LanguageNames.CSharp);
+            /// <inheritdoc cref="SharedVerifierState.Options"/>
+            internal OptionsCollection Options => _sharedState.Options;
 
-            public string? EditorConfig { get; set; }
+            /// <inheritdoc cref="SharedVerifierState.EditorConfig"/>
+            public string? EditorConfig
+            {
+                get => _sharedState.EditorConfig;
+                set => _sharedState.EditorConfig = value;
+            }
 
             public Func<ImmutableArray<Diagnostic>, Diagnostic?>? DiagnosticSelector { get; set; }
 
-            public override async Task RunAsync(CancellationToken cancellationToken = default)
+            public Action<ImmutableArray<CodeAction>>? CodeActionsVerifier { get; set; }
+
+            protected override async Task RunImplAsync(CancellationToken cancellationToken = default)
             {
                 if (DiagnosticSelector is object)
                 {
                     Assert.True(CodeFixTestBehaviors.HasFlag(Testing.CodeFixTestBehaviors.FixOne), $"'{nameof(DiagnosticSelector)}' can only be used with '{nameof(Testing.CodeFixTestBehaviors)}.{nameof(Testing.CodeFixTestBehaviors.FixOne)}'");
                 }
 
-                await base.RunAsync(cancellationToken);
+                _sharedState.Apply();
+                await base.RunImplAsync(cancellationToken);
             }
 
 #if !CODE_STYLE
@@ -113,6 +105,12 @@ protected override AnalyzerOptions GetAnalyzerOptions(Project project)
                 return DiagnosticSelector?.Invoke(fixableDiagnostics)
                     ?? base.TrySelectDiagnosticToFix(fixableDiagnostics);
             }
+
+            protected override ImmutableArray<CodeAction> FilterCodeActions(ImmutableArray<CodeAction> actions)
+            {
+                CodeActionsVerifier?.Invoke(actions);
+                return base.FilterCodeActions(actions);
+            }
         }
     }
 }
diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs
index ac1137fc4802f..8012ac3db1bef 100644
--- a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs
+++ b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Net;
 using System.Threading;
@@ -28,6 +27,8 @@ public static partial class CSharpCodeRefactoringVerifier<TCodeRefactoring>
     {
         public class Test : CSharpCodeRefactoringTest<TCodeRefactoring, XUnitVerifier>
         {
+            private readonly SharedVerifierState _sharedState;
+
             static Test()
             {
                 // If we have outdated defaults from the host unit test application targeting an older .NET Framework, use more
@@ -44,6 +45,8 @@ static Test()
 
             public Test()
             {
+                _sharedState = new SharedVerifierState(this, DefaultFileExt);
+
                 SolutionTransforms.Add((solution, projectId) =>
                 {
                     var parseOptions = (CSharpParseOptions)solution.GetProject(projectId)!.ParseOptions!;
@@ -53,26 +56,6 @@ public Test()
                     compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(compilationOptions.SpecificDiagnosticOptions.SetItems(CSharpVerifierHelper.NullableWarnings));
                     solution = solution.WithProjectCompilationOptions(projectId, compilationOptions);
 
-                    var (analyzerConfigSource, remainingOptions) = CodeFixVerifierHelper.ConvertOptionsToAnalyzerConfig(DefaultFileExt, EditorConfig, Options);
-                    if (analyzerConfigSource is object)
-                    {
-                        foreach (var id in solution.ProjectIds)
-                        {
-                            var documentId = DocumentId.CreateNewId(id, ".editorconfig");
-                            solution = solution.AddAnalyzerConfigDocument(documentId, ".editorconfig", analyzerConfigSource, filePath: "/.editorconfig");
-                        }
-                    }
-
-#if !CODE_STYLE
-                    var options = solution.Options;
-                    foreach (var (key, value) in remainingOptions)
-                    {
-                        options = options.WithChangedOption(key, value);
-                    }
-
-                    solution = solution.WithOptions(options);
-#endif
-
                     return solution;
                 });
             }
@@ -83,13 +66,15 @@ public Test()
             /// </summary>
             public LanguageVersion LanguageVersion { get; set; } = LanguageVersion.CSharp8;
 
-            /// <summary>
-            /// Gets a collection of options to apply to <see cref="Solution.Options"/> for testing. Values may be added
-            /// using a collection initializer.
-            /// </summary>
-            internal OptionsCollection Options { get; } = new OptionsCollection(LanguageNames.CSharp);
+            /// <inheritdoc cref="SharedVerifierState.Options"/>
+            internal OptionsCollection Options => _sharedState.Options;
 
-            public string? EditorConfig { get; set; }
+            /// <inheritdoc cref="SharedVerifierState.EditorConfig"/>
+            public string? EditorConfig
+            {
+                get => _sharedState.EditorConfig;
+                set => _sharedState.EditorConfig = value;
+            }
 
             /// <summary>
             /// The set of code action <see cref="CodeAction.Title"/>s offered the user in this exact order.
@@ -97,6 +82,12 @@ public Test()
             /// </summary>
             public string[]? ExactActionSetOffered { get; set; }
 
+            protected override async Task RunImplAsync(CancellationToken cancellationToken)
+            {
+                _sharedState.Apply();
+                await base.RunImplAsync(cancellationToken);
+            }
+
             protected override ImmutableArray<CodeAction> FilterCodeActions(ImmutableArray<CodeAction> actions)
             {
                 var result = base.FilterCodeActions(actions);
@@ -110,8 +101,6 @@ protected override ImmutableArray<CodeAction> FilterCodeActions(ImmutableArray<C
             }
 
 #if !CODE_STYLE
-            private readonly List<AdhocWorkspace> _workspaces = new();
-
             protected override AnalyzerOptions GetAnalyzerOptions(Project project)
                 => new WorkspaceAnalyzerOptions(base.GetAnalyzerOptions(project), project.Solution);
 
@@ -122,38 +111,15 @@ protected override AnalyzerOptions GetAnalyzerOptions(Project project)
 
             private static readonly TestComposition s_editorFeaturesOOPComposition = EditorTestCompositions.EditorFeatures.WithTestHostParts(TestHost.OutOfProcess);
 
-            public override AdhocWorkspace CreateWorkspace()
+            protected override Workspace CreateWorkspaceImpl()
             {
                 if (TestHost == TestHost.InProcess)
-                    return base.CreateWorkspace();
+                    return base.CreateWorkspaceImpl();
 
                 var hostServices = s_editorFeaturesOOPComposition.GetHostServices();
                 var workspace = new AdhocWorkspace(hostServices);
-                lock (_workspaces)
-                    _workspaces.Add(workspace);
-
                 return workspace;
             }
-
-            public override async Task RunAsync(CancellationToken cancellationToken = default)
-            {
-                try
-                {
-                    await base.RunAsync(cancellationToken).ConfigureAwait(false);
-                }
-                finally
-                {
-                    var workspaces = new List<AdhocWorkspace>();
-                    lock (_workspaces)
-                    {
-                        workspaces.AddRange(_workspaces);
-                        _workspaces.Clear();
-                    }
-
-                    foreach (var workspace in workspaces)
-                        workspace.Dispose();
-                }
-            }
 #endif
         }
     }
diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/SharedVerifierState.cs b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/SharedVerifierState.cs
new file mode 100644
index 0000000000000..c8679afa8e11c
--- /dev/null
+++ b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/SharedVerifierState.cs
@@ -0,0 +1,104 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+
+#if !CODE_STYLE
+using Roslyn.Utilities;
+#endif
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
+{
+    internal sealed class SharedVerifierState
+    {
+        private readonly AnalyzerTest<XUnitVerifier> _test;
+        private readonly string _defaultFileExt;
+
+        /// <summary>
+        /// The index in <see cref="Testing.ProjectState.AnalyzerConfigFiles"/> of the generated
+        /// <strong>.editorconfig</strong> file for <see cref="Options"/>, or <see langword="null"/> if no such
+        /// file has been generated yet.
+        /// </summary>
+        private int? _analyzerConfigIndex;
+
+        /// <summary>
+        /// The index in <see cref="AnalyzerTest{TVerifier}.SolutionTransforms"/> of the options transformation for
+        /// remaining <see cref="Options"/>, or <see langword="null"/> if no such transfor has been generated yet.
+        /// </summary>
+        private Func<Solution, ProjectId, Solution>? _remainingOptionsSolutionTransform;
+
+        public SharedVerifierState(AnalyzerTest<XUnitVerifier> test, string defaultFileExt)
+        {
+            _test = test;
+            _defaultFileExt = defaultFileExt;
+            Options = new OptionsCollection(test.Language);
+        }
+
+        public string? EditorConfig { get; set; }
+
+        /// <summary>
+        /// Gets a collection of options to apply to <see cref="Solution.Options"/> for testing. Values may be added
+        /// using a collection initializer.
+        /// </summary>
+        internal OptionsCollection Options { get; }
+
+        internal void Apply()
+        {
+            var (analyzerConfigSource, remainingOptions) = CodeFixVerifierHelper.ConvertOptionsToAnalyzerConfig(_defaultFileExt, EditorConfig, Options);
+            if (analyzerConfigSource is not null)
+            {
+                if (_analyzerConfigIndex is null)
+                {
+                    _analyzerConfigIndex = _test.TestState.AnalyzerConfigFiles.Count;
+                    _test.TestState.AnalyzerConfigFiles.Add(("/.editorconfig", analyzerConfigSource));
+                }
+                else
+                {
+                    _test.TestState.AnalyzerConfigFiles[_analyzerConfigIndex.Value] = ("/.editorconfig", analyzerConfigSource);
+                }
+            }
+            else if (_analyzerConfigIndex is { } index)
+            {
+                _analyzerConfigIndex = null;
+                _test.TestState.AnalyzerConfigFiles.RemoveAt(index);
+            }
+
+            var solutionTransformIndex = _remainingOptionsSolutionTransform is not null ? _test.SolutionTransforms.IndexOf(_remainingOptionsSolutionTransform) : -1;
+            if (remainingOptions is not null)
+            {
+                // Generate a new solution transform
+                _remainingOptionsSolutionTransform = (solution, projectId) =>
+                {
+#if !CODE_STYLE
+                    var options = solution.Options;
+                    foreach (var (key, value) in remainingOptions)
+                    {
+                        options = options.WithChangedOption(key, value);
+                    }
+
+                    solution = solution.WithOptions(options);
+#endif
+
+                    return solution;
+                };
+
+                if (solutionTransformIndex < 0)
+                {
+                    _test.SolutionTransforms.Add(_remainingOptionsSolutionTransform);
+                }
+                else
+                {
+                    _test.SolutionTransforms[solutionTransformIndex] = _remainingOptionsSolutionTransform;
+                }
+            }
+            else if (_remainingOptionsSolutionTransform is not null)
+            {
+                _test.SolutionTransforms.Remove(_remainingOptionsSolutionTransform);
+                _remainingOptionsSolutionTransform = null;
+            }
+        }
+    }
+}
diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeFixVerifier`2+Test.cs b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeFixVerifier`2+Test.cs
index d63b2636931c9..1ec477ed7b4a6 100644
--- a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeFixVerifier`2+Test.cs
+++ b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeFixVerifier`2+Test.cs
@@ -26,6 +26,8 @@ public static partial class VisualBasicCodeFixVerifier<TAnalyzer, TCodeFix>
     {
         public class Test : VisualBasicCodeFixTest<TAnalyzer, TCodeFix, XUnitVerifier>
         {
+            private readonly SharedVerifierState _sharedState;
+
             static Test()
             {
                 // If we have outdated defaults from the host unit test application targeting an older .NET Framework, use more
@@ -42,6 +44,8 @@ static Test()
 
             public Test()
             {
+                _sharedState = new SharedVerifierState(this, DefaultFileExt);
+
                 MarkupOptions = Testing.MarkupOptions.UseFirstDescriptor;
 
                 SolutionTransforms.Add((solution, projectId) =>
@@ -49,26 +53,6 @@ public Test()
                     var parseOptions = (VisualBasicParseOptions)solution.GetProject(projectId)!.ParseOptions!;
                     solution = solution.WithProjectParseOptions(projectId, parseOptions.WithLanguageVersion(LanguageVersion));
 
-                    var (analyzerConfigSource, remainingOptions) = CodeFixVerifierHelper.ConvertOptionsToAnalyzerConfig(DefaultFileExt, EditorConfig, Options);
-                    if (analyzerConfigSource is object)
-                    {
-                        foreach (var id in solution.ProjectIds)
-                        {
-                            var documentId = DocumentId.CreateNewId(id, ".editorconfig");
-                            solution = solution.AddAnalyzerConfigDocument(documentId, ".editorconfig", analyzerConfigSource, filePath: "/.editorconfig");
-                        }
-                    }
-
-#if !CODE_STYLE
-                    var options = solution.Options;
-                    foreach (var (key, value) in remainingOptions)
-                    {
-                        options = options.WithChangedOption(key, value);
-                    }
-
-                    solution = solution.WithOptions(options);
-#endif
-
                     return solution;
                 });
             }
@@ -79,24 +63,27 @@ public Test()
             /// </summary>
             public LanguageVersion LanguageVersion { get; set; } = LanguageVersion.VisualBasic16;
 
-            /// <summary>
-            /// Gets a collection of options to apply to <see cref="Solution.Options"/> for testing. Values may be added
-            /// using a collection initializer.
-            /// </summary>
-            internal OptionsCollection Options { get; } = new OptionsCollection(LanguageNames.VisualBasic);
+            /// <inheritdoc cref="SharedVerifierState.Options"/>
+            internal OptionsCollection Options => _sharedState.Options;
 
-            public string? EditorConfig { get; set; }
+            /// <inheritdoc cref="SharedVerifierState.EditorConfig"/>
+            public string? EditorConfig
+            {
+                get => _sharedState.EditorConfig;
+                set => _sharedState.EditorConfig = value;
+            }
 
             public Func<ImmutableArray<Diagnostic>, Diagnostic?>? DiagnosticSelector { get; set; }
 
-            public override async Task RunAsync(CancellationToken cancellationToken = default)
+            protected override async Task RunImplAsync(CancellationToken cancellationToken = default)
             {
                 if (DiagnosticSelector is object)
                 {
                     Assert.True(CodeFixTestBehaviors.HasFlag(Testing.CodeFixTestBehaviors.FixOne), $"'{nameof(DiagnosticSelector)}' can only be used with '{nameof(Testing.CodeFixTestBehaviors)}.{nameof(Testing.CodeFixTestBehaviors.FixOne)}'");
                 }
 
-                await base.RunAsync(cancellationToken);
+                _sharedState.Apply();
+                await base.RunImplAsync(cancellationToken);
             }
 
 #if !CODE_STYLE
diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeRefactoringVerifier`1+Test.cs b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeRefactoringVerifier`1+Test.cs
index 0a20d8d15b116..727be29d9a845 100644
--- a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeRefactoringVerifier`1+Test.cs
+++ b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeRefactoringVerifier`1+Test.cs
@@ -3,10 +3,12 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
 using Microsoft.CodeAnalysis.VisualBasic;
 using Microsoft.CodeAnalysis.VisualBasic.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-using Microsoft.CodeAnalysis.CodeRefactorings;
 
 #if !CODE_STYLE
 using System;
@@ -21,6 +23,8 @@ public static partial class VisualBasicCodeRefactoringVerifier<TCodeRefactoring>
     {
         public class Test : VisualBasicCodeRefactoringTest<TCodeRefactoring, XUnitVerifier>
         {
+            private readonly SharedVerifierState _sharedState;
+
             static Test()
             {
                 // If we have outdated defaults from the host unit test application targeting an older .NET Framework, use more
@@ -37,31 +41,13 @@ static Test()
 
             public Test()
             {
+                _sharedState = new SharedVerifierState(this, DefaultFileExt);
+
                 SolutionTransforms.Add((solution, projectId) =>
                 {
                     var parseOptions = (VisualBasicParseOptions)solution.GetProject(projectId)!.ParseOptions!;
                     solution = solution.WithProjectParseOptions(projectId, parseOptions.WithLanguageVersion(LanguageVersion));
 
-                    var (analyzerConfigSource, remainingOptions) = CodeFixVerifierHelper.ConvertOptionsToAnalyzerConfig(DefaultFileExt, EditorConfig, Options);
-                    if (analyzerConfigSource is object)
-                    {
-                        foreach (var id in solution.ProjectIds)
-                        {
-                            var documentId = DocumentId.CreateNewId(id, ".editorconfig");
-                            solution = solution.AddAnalyzerConfigDocument(documentId, ".editorconfig", analyzerConfigSource, filePath: "/.editorconfig");
-                        }
-                    }
-
-#if !CODE_STYLE
-                    var options = solution.Options;
-                    foreach (var (key, value) in remainingOptions)
-                    {
-                        options = options.WithChangedOption(key, value);
-                    }
-
-                    solution = solution.WithOptions(options);
-#endif
-
                     return solution;
                 });
             }
@@ -72,13 +58,21 @@ public Test()
             /// </summary>
             public LanguageVersion LanguageVersion { get; set; } = LanguageVersion.VisualBasic16;
 
-            /// <summary>
-            /// Gets a collection of options to apply to <see cref="Solution.Options"/> for testing. Values may be added
-            /// using a collection initializer.
-            /// </summary>
-            internal OptionsCollection Options { get; } = new OptionsCollection(LanguageNames.VisualBasic);
+            /// <inheritdoc cref="SharedVerifierState.Options"/>
+            internal OptionsCollection Options => _sharedState.Options;
 
-            public string? EditorConfig { get; set; }
+            /// <inheritdoc cref="SharedVerifierState.EditorConfig"/>
+            public string? EditorConfig
+            {
+                get => _sharedState.EditorConfig;
+                set => _sharedState.EditorConfig = value;
+            }
+
+            protected override async Task RunImplAsync(CancellationToken cancellationToken)
+            {
+                _sharedState.Apply();
+                await base.RunImplAsync(cancellationToken);
+            }
 
 #if !CODE_STYLE
             protected override AnalyzerOptions GetAnalyzerOptions(Project project)
diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/AbstractDiagnosticProviderBasedUserDiagnosticTest.cs b/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/AbstractDiagnosticProviderBasedUserDiagnosticTest.cs
index e6385ffafa1e7..fbf4d02990764 100644
--- a/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/AbstractDiagnosticProviderBasedUserDiagnosticTest.cs
+++ b/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/AbstractDiagnosticProviderBasedUserDiagnosticTest.cs
@@ -59,6 +59,7 @@ internal virtual bool ShouldSkipMessageDescriptionVerification(DiagnosticDescrip
                     return true;
                 }
             }
+
             return false;
         }
 
diff --git a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.Shared.cs b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.Shared.cs
index 81e2cfb3ee098..40cbb9df11e6a 100644
--- a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.Shared.cs
+++ b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.Shared.cs
@@ -705,7 +705,7 @@ public class A
             public static abstract string Property1 { get; }
             public virtual string Property { get; }
 
-            public abstract static void Method2();
+            public static abstract void Method2();
             public virtual void Method1();
         }
 
diff --git a/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs b/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs
index 559dbdedb94e3..936471ea40450 100644
--- a/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs
+++ b/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs
@@ -402,6 +402,9 @@ public void CSharp_VerifyIDEDiagnosticSeveritiesAreConfigurable()
 # IDE0100
 dotnet_diagnostic.IDE0100.severity = %value%
 
+# IDE0150
+dotnet_diagnostic.IDE0150.severity = %value%
+
 # IDE1005
 dotnet_diagnostic.IDE1005.severity = %value%
 
@@ -989,6 +992,9 @@ No editorconfig based code style option
 # IDE0130, PreferNamespaceAndFolderMatchStructure
 dotnet_style_namespace_match_folder = true
 
+# IDE0150
+No editorconfig based code style option
+
 # IDE1005, PreferConditionalDelegateCall
 csharp_style_conditional_delegate_call = true
 
diff --git a/src/EditorFeatures/Test/DocCommentFormatting/DocCommentFormattingTests.cs b/src/EditorFeatures/Test/DocCommentFormatting/DocCommentFormattingTests.cs
index 9a23741881b7d..3d8d8e9e73134 100644
--- a/src/EditorFeatures/Test/DocCommentFormatting/DocCommentFormattingTests.cs
+++ b/src/EditorFeatures/Test/DocCommentFormatting/DocCommentFormattingTests.cs
@@ -50,7 +50,7 @@ public void ExampleAndCodeTags()
             results in <c>p</c>'s having the value (2,8).
             </example>";
 
-            var expected = "This method changes the point's location by the given x- and y-offsets. For example:\r\n\r\nPoint p = new Point(3,5); p.Translate(-1,3);\r\n\r\nresults in p's having the value (2,8).";
+            var expected = "This method changes the point's location by the given x- and y-offsets. For example:\r\n\r\n            Point p = new Point(3,5);\r\n            p.Translate(-1,3);\r\n            \r\n\r\nresults in p's having the value (2,8).";
 
             TestFormat(comment, expected);
         }
diff --git a/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs b/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
index 6f9478481297d..c431c78d5336b 100644
--- a/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
+++ b/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
@@ -1905,6 +1905,7 @@ void ValidateDelta(ManagedModuleUpdate delta)
                 Assert.NotEmpty(delta.MetadataDelta);
                 Assert.NotEmpty(delta.PdbDelta);
                 Assert.Equal(0x06000001, delta.UpdatedMethods.Single());
+                Assert.Equal(0x02000002, delta.UpdatedTypes.Single());
                 Assert.Equal(moduleId, delta.Module);
                 Assert.Empty(delta.ExceptionRegions);
                 Assert.Empty(delta.SequencePoints);
@@ -2042,6 +2043,7 @@ public async Task BreakMode_ValidSignificantChange_EmitSuccessful_UpdateDeferred
             Assert.NotEmpty(delta.MetadataDelta);
             Assert.NotEmpty(delta.PdbDelta);
             Assert.Equal(0x06000002, delta.UpdatedMethods.Single());
+            Assert.Equal(0x02000002, delta.UpdatedTypes.Single());
             Assert.Equal(moduleId, delta.Module);
             Assert.Empty(delta.ExceptionRegions);
             Assert.Empty(delta.SequencePoints);
@@ -2157,6 +2159,7 @@ partial class C { int Y = 2; }
             Assert.NotEmpty(delta.MetadataDelta);
             Assert.NotEmpty(delta.PdbDelta);
             Assert.Equal(6, delta.UpdatedMethods.Length);  // F, C.C(), D.D(), E.E(int), E.E(int, int), lambda
+            AssertEx.SetEqual(new[] { 0x02000002, 0x02000003, 0x02000004, 0x02000005 }, delta.UpdatedTypes, itemInspector: t => "0x" + t.ToString("X"));
 
             EndDebuggingSession(debuggingSession);
         }
@@ -2271,6 +2274,7 @@ class C { int Y => 2; }
             Assert.NotEmpty(delta.MetadataDelta);
             Assert.NotEmpty(delta.PdbDelta);
             Assert.Equal(2, delta.UpdatedMethods.Length);
+            AssertEx.Equal(new[] { 0x02000002, 0x02000003 }, delta.UpdatedTypes, itemInspector: t => "0x" + t.ToString("X"));
 
             EndDebuggingSession(debuggingSession);
         }
@@ -2332,6 +2336,7 @@ int M()
             Assert.NotEmpty(delta.MetadataDelta);
             Assert.NotEmpty(delta.PdbDelta);
             Assert.Empty(delta.UpdatedMethods);
+            Assert.Empty(delta.UpdatedTypes);
 
             EndDebuggingSession(debuggingSession);
         }
@@ -2375,6 +2380,7 @@ partial class C { int X = 1; }
             Assert.NotEmpty(delta.MetadataDelta);
             Assert.NotEmpty(delta.PdbDelta);
             Assert.Equal(1, delta.UpdatedMethods.Length); // constructor update
+            Assert.Equal(0x02000002, delta.UpdatedTypes.Single());
 
             EndDebuggingSession(debuggingSession);
         }
@@ -2421,6 +2427,7 @@ class C { int Y => 1; }
             Assert.NotEmpty(delta.MetadataDelta);
             Assert.NotEmpty(delta.PdbDelta);
             Assert.Equal(1, delta.UpdatedMethods.Length);
+            Assert.Equal(0x02000003, delta.UpdatedTypes.Single());
 
             EndDebuggingSession(debuggingSession);
         }
@@ -2463,6 +2470,7 @@ class C { int Y => 1; }
             Assert.NotEmpty(delta.MetadataDelta);
             Assert.NotEmpty(delta.PdbDelta);
             Assert.Equal(1, delta.UpdatedMethods.Length);
+            Assert.Equal(0x02000003, delta.UpdatedTypes.Single());
 
             EndDebuggingSession(debuggingSession);
         }
@@ -2502,6 +2510,7 @@ public async Task BreakMode_ValidSignificantChange_SourceGenerators_DocumentRemo
             Assert.NotEmpty(delta.MetadataDelta);
             Assert.NotEmpty(delta.PdbDelta);
             Assert.Equal(1, delta.UpdatedMethods.Length);
+            Assert.Equal(0x02000002, delta.UpdatedTypes.Single());
 
             EndDebuggingSession(debuggingSession);
         }
@@ -3191,6 +3200,7 @@ void F()
             Assert.NotEmpty(delta.MetadataDelta);
             Assert.NotEmpty(delta.PdbDelta);
             Assert.Empty(delta.UpdatedMethods);
+            Assert.Empty(delta.UpdatedTypes);
 
             AssertEx.Equal(new[]
             {
@@ -3260,6 +3270,7 @@ static void F()
             var (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
             Assert.Empty(emitDiagnostics);
             Assert.Equal(0x06000003, updates.Updates.Single().UpdatedMethods.Single());
+            Assert.Equal(0x02000002, updates.Updates.Single().UpdatedTypes.Single());
             Assert.Equal(ManagedModuleUpdateStatus.Ready, updates.Status);
 
             CommitSolutionUpdate(debuggingSession);
@@ -3278,6 +3289,7 @@ static void F()
             (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
             Assert.Empty(emitDiagnostics);
             Assert.Equal(0x06000003, updates.Updates.Single().UpdatedMethods.Single());
+            Assert.Equal(0x02000002, updates.Updates.Single().UpdatedTypes.Single());
             Assert.Equal(ManagedModuleUpdateStatus.Ready, updates.Status);
 
             CommitSolutionUpdate(debuggingSession);
@@ -3305,6 +3317,7 @@ static void F()
             (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
             Assert.Empty(emitDiagnostics);
             Assert.Equal(0x06000003, updates.Updates.Single().UpdatedMethods.Single());
+            Assert.Equal(0x02000002, updates.Updates.Single().UpdatedTypes.Single());
             Assert.Equal(ManagedModuleUpdateStatus.Ready, updates.Status);
 
             CommitSolutionUpdate(debuggingSession);
@@ -3431,6 +3444,7 @@ static void F()
             var (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
             Assert.Empty(emitDiagnostics);
             Assert.Equal(0x06000003, updates.Updates.Single().UpdatedMethods.Single());
+            Assert.Equal(0x02000002, updates.Updates.Single().UpdatedTypes.Single());
             Assert.Equal(ManagedModuleUpdateStatus.Ready, updates.Status);
 
             CommitSolutionUpdate(debuggingSession);
@@ -3489,6 +3503,7 @@ static void F()
             var (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
             Assert.Empty(emitDiagnostics);
             Assert.Equal(0x06000003, updates.Updates.Single().UpdatedMethods.Single());
+            Assert.Equal(0x02000002, updates.Updates.Single().UpdatedTypes.Single());
             Assert.Equal(ManagedModuleUpdateStatus.Ready, updates.Status);
 
             CommitSolutionUpdate(debuggingSession);
@@ -3625,6 +3640,7 @@ public async Task WatchHotReloadServiceTest()
             var result = await hotReload.EmitSolutionUpdateAsync(solution, CancellationToken.None);
             Assert.Empty(result.diagnostics);
             Assert.Equal(1, result.updates.Length);
+            AssertEx.Equal(new[] { 0x02000002 }, result.updates[0].UpdatedTypes);
 
             solution = solution.WithDocumentText(documentIdA, SourceText.From(source3, Encoding.UTF8));
 
@@ -3666,7 +3682,7 @@ public async Task UnitTestingHotReloadServiceTest()
 
             var hotReload = new UnitTestingHotReloadService(workspace.Services);
 
-            await hotReload.StartSessionAsync(solution, CancellationToken.None);
+            await hotReload.StartSessionAsync(solution, ImmutableArray.Create("Baseline", "AddDefinitionToExistingType", "NewTypeDefinition"), CancellationToken.None);
 
             var sessionId = hotReload.GetTestAccessor().SessionId;
             var session = encService.GetTestAccessor().GetDebuggingSession(sessionId);
@@ -3678,13 +3694,13 @@ public async Task UnitTestingHotReloadServiceTest()
 
             solution = solution.WithDocumentText(documentIdA, SourceText.From(source2, Encoding.UTF8));
 
-            var result = await hotReload.EmitSolutionUpdateAsync(solution, CancellationToken.None);
+            var result = await hotReload.EmitSolutionUpdateAsync(solution, true, CancellationToken.None);
             Assert.Empty(result.diagnostics);
             Assert.Equal(1, result.updates.Length);
 
             solution = solution.WithDocumentText(documentIdA, SourceText.From(source3, Encoding.UTF8));
 
-            result = await hotReload.EmitSolutionUpdateAsync(solution, CancellationToken.None);
+            result = await hotReload.EmitSolutionUpdateAsync(solution, true, CancellationToken.None);
             AssertEx.Equal(
                 new[] { "ENC0020: " + string.Format(FeaturesResources.Renaming_0_will_prevent_the_debug_session_from_continuing, FeaturesResources.method) },
                 result.diagnostics.Select(d => $"{d.Id}: {d.GetMessage()}"));
diff --git a/src/EditorFeatures/Test/EditorAdapter/SpanExtensionsTest.cs b/src/EditorFeatures/Test/EditorAdapter/SpanExtensionsTest.cs
index 2f89cdba54c7f..edb1dcc2413ea 100644
--- a/src/EditorFeatures/Test/EditorAdapter/SpanExtensionsTest.cs
+++ b/src/EditorFeatures/Test/EditorAdapter/SpanExtensionsTest.cs
@@ -25,6 +25,7 @@ static void del(int start, int length)
                 Assert.Equal(start, textSpan.Start);
                 Assert.Equal(length, textSpan.Length);
             }
+
             del(0, 5);
             del(10, 15);
         }
diff --git a/src/EditorFeatures/Test/InheritanceMargin/InheritanceMarginTests.cs b/src/EditorFeatures/Test/InheritanceMargin/InheritanceMarginTests.cs
index 5dd0a86442d4c..da73cc155115a 100644
--- a/src/EditorFeatures/Test/InheritanceMargin/InheritanceMarginTests.cs
+++ b/src/EditorFeatures/Test/InheritanceMargin/InheritanceMarginTests.cs
@@ -296,7 +296,7 @@ public class Bar : IEnumerable
                 memberName: "class Bar",
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "interface IEnumerable",
-                        relationship: InheritanceRelationship.Implementing,
+                        relationship: InheritanceRelationship.ImplementedInterface,
                         inMetadata: true)));
 
             var itemForGetEnumerator = new TestInheritanceMemberItem(
@@ -304,7 +304,7 @@ public class Bar : IEnumerable
                 memberName: "IEnumerator Bar.GetEnumerator()",
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "IEnumerator IEnumerable.GetEnumerator()",
-                        relationship: InheritanceRelationship.Implementing,
+                        relationship: InheritanceRelationship.ImplementedMember,
                         inMetadata: true)));
 
             return VerifyInSingleDocumentAsync(markup, LanguageNames.CSharp, itemForBar, itemForGetEnumerator);
@@ -326,7 +326,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class Bar",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingType)));
 
             var itemOnLine3 = new TestInheritanceMemberItem(
                 lineNumber: 3,
@@ -334,7 +334,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "interface IBar",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedInterface)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -347,9 +347,9 @@ public class {|target2:Bar|} : IBar
         public Task TestCSharpInterfaceImplementingInterface()
         {
             var markup = @"
-interface {|target1:IBar|} { }
-interface {|target2:IBar2|} : IBar { }
-            ";
+        interface {|target1:IBar|} { }
+        interface {|target2:IBar2|} : IBar { }
+                    ";
 
             var itemOnLine2 = new TestInheritanceMemberItem(
                 lineNumber: 2,
@@ -357,7 +357,7 @@ interface {|target2:IBar2|} : IBar { }
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "interface IBar2",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implemented))
+                        relationship: InheritanceRelationship.ImplementingType))
                 );
             var itemOnLine3 = new TestInheritanceMemberItem(
                 lineNumber: 3,
@@ -366,7 +366,7 @@ interface {|target2:IBar2|} : IBar { }
                     .Add(new TargetInfo(
                         targetSymbolDisplayName: "interface IBar",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implementing))
+                        relationship: InheritanceRelationship.InheritedInterface))
                 );
 
             return VerifyInSingleDocumentAsync(
@@ -380,9 +380,9 @@ interface {|target2:IBar2|} : IBar { }
         public Task TestCSharpClassInheritsClass()
         {
             var markup = @"
-class {|target2:A|} { }
-class {|target1:B|} : A { }
-            ";
+        class {|target2:A|} { }
+        class {|target1:B|} : A { }
+                    ";
 
             var itemOnLine2 = new TestInheritanceMemberItem(
                 lineNumber: 2,
@@ -390,7 +390,7 @@ class {|target1:B|} : A { }
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class B",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implemented))
+                        relationship: InheritanceRelationship.DerivedType))
             );
             var itemOnLine3 = new TestInheritanceMemberItem(
                 lineNumber: 3,
@@ -398,7 +398,7 @@ class {|target1:B|} : A { }
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class A",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implementing))
+                        relationship: InheritanceRelationship.BaseType))
             );
 
             return VerifyInSingleDocumentAsync(
@@ -416,9 +416,9 @@ class {|target1:B|} : A { }
         public Task TestCSharpTypeWithoutBaseType(string typeName)
         {
             var markup = $@"
-public {typeName} Bar
-{{
-}}";
+        public {typeName} Bar
+        {{
+        }}";
             return VerifyNoItemForDocumentAsync(markup, LanguageNames.CSharp);
         }
 
@@ -430,12 +430,12 @@ public Task TestCSharpTypeWithoutBaseType(string typeName)
         public Task TestCSharpSpecialMember(string memberDeclaration)
         {
             var markup = $@"
-public abstract class {{|target1:Bar1|}}
-{{}}
-public class Bar : Bar1
-{{
-    {{|{SearchAreaTag}:{memberDeclaration}|}}
-}}";
+        public abstract class {{|target1:Bar1|}}
+        {{}}
+        public class Bar : Bar1
+        {{
+            {{|{SearchAreaTag}:{memberDeclaration}|}}
+        }}";
             return VerifyInSingleDocumentAsync(
                 markup,
                 LanguageNames.CSharp,
@@ -446,53 +446,32 @@ public class Bar : Bar1
                         new TargetInfo(
                             targetSymbolDisplayName: "class Bar1",
                             locationTag: "target1",
-                            relationship: InheritanceRelationship.Implementing))));
+                            relationship: InheritanceRelationship.BaseType))));
         }
 
         [Fact]
-        public Task TestCSharpMetadataInterface()
+        public Task TestCSharpEventDeclaration()
         {
             var markup = @"
-using System.Collections;
-public class Bar : IEnumerable
-{
-}";
-            return VerifyInSingleDocumentAsync(
-                markup,
-                LanguageNames.CSharp,
-                new TestInheritanceMemberItem(
-                    lineNumber: 3,
-                    memberName: "class Bar",
-                    targets: ImmutableArray.Create(
-                        new TargetInfo(
-                                targetSymbolDisplayName: "interface IEnumerable",
-                                relationship: InheritanceRelationship.Implementing,
-                                inMetadata: true))));
+        using System;
+        interface {|target2:IBar|}
+        {
+            event EventHandler {|target4:e|};
         }
-
-        [Fact]
-        public Task TestCSharpEventDeclaration()
+        public class {|target1:Bar|} : IBar
         {
-            var markup = @"
-using System;
-interface {|target2:IBar|}
-{
-    event EventHandler {|target4:e|};
-}
-public class {|target1:Bar|} : IBar
-{
-    public event EventHandler {|target3:e|}
-    {
-        add {} remove {}
-    }
-}";
+            public event EventHandler {|target3:e|}
+            {
+                add {} remove {}
+            }
+        }";
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 3,
                 memberName: "interface IBar",
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "class Bar",
                     locationTag: "target1",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 7,
@@ -500,7 +479,7 @@ public class {|target1:Bar|} : IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "interface IBar",
                     locationTag: "target2",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForEventInInterface = new TestInheritanceMemberItem(
                 lineNumber: 5,
@@ -508,7 +487,7 @@ public class {|target1:Bar|} : IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "event EventHandler Bar.e",
                     locationTag: "target3",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForEventInClass = new TestInheritanceMemberItem(
                 lineNumber: 9,
@@ -516,7 +495,7 @@ public class {|target1:Bar|} : IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "event EventHandler IBar.e",
                     locationTag: "target4",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedMember)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -531,21 +510,21 @@ public class {|target1:Bar|} : IBar
         public Task TestCSharpEventFieldDeclarations()
         {
             var markup = @"using System;
-interface {|target2:IBar|}
-{
-    event EventHandler {|target5:e1|}, {|target6:e2|};
-}
-public class {|target1:Bar|} : IBar
-{
-    public event EventHandler {|target3:e1|}, {|target4:e2|};
-}";
+        interface {|target2:IBar|}
+        {
+            event EventHandler {|target5:e1|}, {|target6:e2|};
+        }
+        public class {|target1:Bar|} : IBar
+        {
+            public event EventHandler {|target3:e1|}, {|target4:e2|};
+        }";
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 2,
                 memberName: "interface IBar",
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "class Bar",
                     locationTag: "target1",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 6,
@@ -553,7 +532,7 @@ public class {|target1:Bar|} : IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "interface IBar",
                     locationTag: "target2",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForE1InInterface = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -561,7 +540,7 @@ public class {|target1:Bar|} : IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "event EventHandler Bar.e1",
                     locationTag: "target3",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForE2InInterface = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -569,7 +548,7 @@ public class {|target1:Bar|} : IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "event EventHandler Bar.e2",
                     locationTag: "target4",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForE1InClass = new TestInheritanceMemberItem(
                 lineNumber: 8,
@@ -577,7 +556,7 @@ public class {|target1:Bar|} : IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "event EventHandler IBar.e1",
                     locationTag: "target5",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedMember)));
 
             var itemForE2InClass = new TestInheritanceMemberItem(
                 lineNumber: 8,
@@ -585,7 +564,7 @@ public class {|target1:Bar|} : IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "event EventHandler IBar.e2",
                     locationTag: "target6",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedMember)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -602,27 +581,27 @@ public class {|target1:Bar|} : IBar
         public Task TestCSharpInterfaceMembers()
         {
             var markup = @"using System;
-interface {|target1:IBar|}
-{
-    void {|target4:Foo|}();
-    int {|target6:Poo|} { get; set; }
-    event EventHandler {|target8:Eoo|};
-    int {|target9:this|}[int i] { get; set; }
-}
-public class {|target2:Bar|} : IBar
-{
-    public void {|target3:Foo|}() { }
-    public int {|target5:Poo|} { get; set; }
-    public event EventHandler {|target7:Eoo|};
-    public int {|target10:this|}[int i] { get => 1; set { } }
-}";
+        interface {|target1:IBar|}
+        {
+            void {|target4:Foo|}();
+            int {|target6:Poo|} { get; set; }
+            event EventHandler {|target8:Eoo|};
+            int {|target9:this|}[int i] { get; set; }
+        }
+        public class {|target2:Bar|} : IBar
+        {
+            public void {|target3:Foo|}() { }
+            public int {|target5:Poo|} { get; set; }
+            public event EventHandler {|target7:Eoo|};
+            public int {|target10:this|}[int i] { get => 1; set { } }
+        }";
             var itemForEooInClass = new TestInheritanceMemberItem(
                 lineNumber: 13,
                 memberName: "event EventHandler Bar.Eoo",
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "event EventHandler IBar.Eoo",
                         locationTag: "target8",
-                        relationship: InheritanceRelationship.Implementing))
+                        relationship: InheritanceRelationship.ImplementedMember))
                 );
 
             var itemForEooInInterface = new TestInheritanceMemberItem(
@@ -631,7 +610,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "event EventHandler Bar.Eoo",
                         locationTag: "target7",
-                        relationship: InheritanceRelationship.Implemented))
+                        relationship: InheritanceRelationship.ImplementingMember))
                 );
 
             var itemForPooInInterface = new TestInheritanceMemberItem(
@@ -640,7 +619,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "int Bar.Poo { get; set; }",
                         locationTag: "target5",
-                        relationship: InheritanceRelationship.Implemented))
+                        relationship: InheritanceRelationship.ImplementingMember))
                 );
 
             var itemForPooInClass = new TestInheritanceMemberItem(
@@ -649,7 +628,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "int IBar.Poo { get; set; }",
                         locationTag: "target6",
-                        relationship: InheritanceRelationship.Implementing))
+                        relationship: InheritanceRelationship.ImplementedMember))
                 );
 
             var itemForFooInInterface = new TestInheritanceMemberItem(
@@ -658,7 +637,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void Bar.Foo()",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Implemented))
+                        relationship: InheritanceRelationship.ImplementingMember))
                 );
 
             var itemForFooInClass = new TestInheritanceMemberItem(
@@ -667,7 +646,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void IBar.Foo()",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Implementing))
+                        relationship: InheritanceRelationship.ImplementedMember))
                 );
 
             var itemForIBar = new TestInheritanceMemberItem(
@@ -676,7 +655,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class Bar",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implemented))
+                        relationship: InheritanceRelationship.ImplementingType))
                 );
 
             var itemForBar = new TestInheritanceMemberItem(
@@ -685,7 +664,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "interface IBar",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implementing))
+                        relationship: InheritanceRelationship.ImplementedInterface))
                 );
 
             var itemForIndexerInClass = new TestInheritanceMemberItem(
@@ -694,7 +673,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "int IBar.this[int] { get; set; }",
                         locationTag: "target9",
-                        relationship: InheritanceRelationship.Implementing))
+                        relationship: InheritanceRelationship.ImplementedMember))
                 );
 
             var itemForIndexerInInterface = new TestInheritanceMemberItem(
@@ -703,7 +682,7 @@ public class {|target2:Bar|} : IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "int Bar.this[int] { get; set; }",
                         locationTag: "target10",
-                        relationship: InheritanceRelationship.Implemented))
+                        relationship: InheritanceRelationship.ImplementingMember))
                 );
 
             return VerifyInSingleDocumentAsync(
@@ -727,19 +706,19 @@ public class {|target2:Bar|} : IBar
         public Task TestCSharpAbstractClassMembers(string modifier)
         {
             var markup = $@"using System;
-public abstract class {{|target2:Bar|}}
-{{
-    public {modifier} void {{|target4:Foo|}}();
-    public {modifier} int {{|target6:Poo|}} {{ get; set; }}
-    public {modifier} event EventHandler {{|target8:Eoo|}};
-}}
-public class {{|target1:Bar2|}} : Bar
-{{
-    public override void {{|target3:Foo|}}() {{ }}
-    public override int {{|target5:Poo|}} {{ get; set; }}
-    public override event EventHandler {{|target7:Eoo|}};
-}}
-            ";
+        public abstract class {{|target2:Bar|}}
+        {{
+            public {modifier} void {{|target4:Foo|}}();
+            public {modifier} int {{|target6:Poo|}} {{ get; set; }}
+            public {modifier} event EventHandler {{|target8:Eoo|}};
+        }}
+        public class {{|target1:Bar2|}} : Bar
+        {{
+            public override void {{|target3:Foo|}}() {{ }}
+            public override int {{|target5:Poo|}} {{ get; set; }}
+            public override event EventHandler {{|target7:Eoo|}};
+        }}
+                    ";
 
             var itemForEooInClass = new TestInheritanceMemberItem(
                 lineNumber: 12,
@@ -747,7 +726,7 @@ public class {{|target1:Bar2|}} : Bar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: $"{modifier} event EventHandler Bar.Eoo",
                         locationTag: "target8",
-                        relationship: InheritanceRelationship.Overriding)));
+                        relationship: InheritanceRelationship.OverriddenMember)));
 
             var itemForEooInAbstractClass = new TestInheritanceMemberItem(
                 lineNumber: 6,
@@ -755,7 +734,7 @@ public class {{|target1:Bar2|}} : Bar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "override event EventHandler Bar2.Eoo",
                         locationTag: "target7",
-                        relationship: InheritanceRelationship.Overridden)));
+                        relationship: InheritanceRelationship.OverridingMember)));
 
             var itemForPooInClass = new TestInheritanceMemberItem(
                     lineNumber: 11,
@@ -763,7 +742,7 @@ public class {{|target1:Bar2|}} : Bar
                     targets: ImmutableArray.Create(new TargetInfo(
                             targetSymbolDisplayName: $"{modifier} int Bar.Poo {{ get; set; }}",
                             locationTag: "target6",
-                            relationship: InheritanceRelationship.Overriding)));
+                            relationship: InheritanceRelationship.OverriddenMember)));
 
             var itemForPooInAbstractClass = new TestInheritanceMemberItem(
                     lineNumber: 5,
@@ -771,7 +750,7 @@ public class {{|target1:Bar2|}} : Bar
                     targets: ImmutableArray.Create(new TargetInfo(
                             targetSymbolDisplayName: "override int Bar2.Poo { get; set; }",
                             locationTag: "target5",
-                            relationship: InheritanceRelationship.Overridden)));
+                            relationship: InheritanceRelationship.OverridingMember)));
 
             var itemForFooInAbstractClass = new TestInheritanceMemberItem(
                     lineNumber: 4,
@@ -779,7 +758,7 @@ public class {{|target1:Bar2|}} : Bar
                     targets: ImmutableArray.Create(new TargetInfo(
                             targetSymbolDisplayName: "override void Bar2.Foo()",
                             locationTag: "target3",
-                            relationship: InheritanceRelationship.Overridden)));
+                            relationship: InheritanceRelationship.OverridingMember)));
 
             var itemForFooInClass = new TestInheritanceMemberItem(
                 lineNumber: 10,
@@ -787,7 +766,7 @@ public class {{|target1:Bar2|}} : Bar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: $"{modifier} void Bar.Foo()",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Overriding)));
+                        relationship: InheritanceRelationship.OverriddenMember)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 2,
@@ -795,7 +774,7 @@ public class {{|target1:Bar2|}} : Bar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class Bar2",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.DerivedType)));
 
             var itemForBar2 = new TestInheritanceMemberItem(
                 lineNumber: 8,
@@ -803,7 +782,7 @@ public class {{|target1:Bar2|}} : Bar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class Bar",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.BaseType)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -823,32 +802,32 @@ public class {{|target1:Bar2|}} : Bar
         public Task TestCSharpOverrideMemberCanFindImplementingInterface(bool testDuplicate)
         {
             var markup1 = @"using System;
-public interface {|target4:IBar|}
-{
-    void {|target6:Foo|}();
-}
-public class {|target1:Bar1|} : IBar
-{
-    public virtual void {|target2:Foo|}() { }
-}
-public class {|target5:Bar2|} : Bar1
-{
-    public override void {|target3:Foo|}() { }
-}";
+        public interface {|target4:IBar|}
+        {
+            void {|target6:Foo|}();
+        }
+        public class {|target1:Bar1|} : IBar
+        {
+            public virtual void {|target2:Foo|}() { }
+        }
+        public class {|target5:Bar2|} : Bar1
+        {
+            public override void {|target3:Foo|}() { }
+        }";
 
             var markup2 = @"using System;
-public interface {|target4:IBar|}
-{
-    void {|target6:Foo|}();
-}
-public class {|target1:Bar1|} : IBar
-{
-    public virtual void {|target2:Foo|}() { }
-}
-public class {|target5:Bar2|} : Bar1, IBar
-{
-    public override void {|target3:Foo|}() { }
-}";
+        public interface {|target4:IBar|}
+        {
+            void {|target6:Foo|}();
+        }
+        public class {|target1:Bar1|} : IBar
+        {
+            public virtual void {|target2:Foo|}() { }
+        }
+        public class {|target5:Bar2|} : Bar1, IBar
+        {
+            public override void {|target3:Foo|}() { }
+        }";
 
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 2,
@@ -856,11 +835,11 @@ public class {|target5:Bar2|} : Bar1, IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class Bar1",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implemented),
+                        relationship: InheritanceRelationship.ImplementingType),
                 new TargetInfo(
                     targetSymbolDisplayName: "class Bar2",
                     locationTag: "target5",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForFooInIBar = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -868,11 +847,11 @@ public class {|target5:Bar2|} : Bar1, IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "virtual void Bar1.Foo()",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implemented),
+                        relationship: InheritanceRelationship.ImplementingMember),
                     new TargetInfo(
                         targetSymbolDisplayName: "override void Bar2.Foo()",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForBar1 = new TestInheritanceMemberItem(
                 lineNumber: 6,
@@ -880,11 +859,11 @@ public class {|target5:Bar2|} : Bar1, IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "interface IBar",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Implementing),
+                        relationship: InheritanceRelationship.ImplementedInterface),
                     new TargetInfo(
                         targetSymbolDisplayName: "class Bar2",
                         locationTag: "target5",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.DerivedType)));
 
             var itemForFooInBar1 = new TestInheritanceMemberItem(
                 lineNumber: 8,
@@ -892,11 +871,11 @@ public class {|target5:Bar2|} : Bar1, IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void IBar.Foo()",
                         locationTag: "target6",
-                        relationship: InheritanceRelationship.Implementing),
+                        relationship: InheritanceRelationship.ImplementedMember),
                     new TargetInfo(
                         targetSymbolDisplayName: "override void Bar2.Foo()",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Overridden)));
+                        relationship: InheritanceRelationship.OverridingMember)));
 
             var itemForBar2 = new TestInheritanceMemberItem(
                 lineNumber: 10,
@@ -905,11 +884,11 @@ public class {|target5:Bar2|} : Bar1, IBar
                     new TargetInfo(
                         targetSymbolDisplayName: "class Bar1",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implementing),
+                        relationship: InheritanceRelationship.BaseType),
                     new TargetInfo(
                         targetSymbolDisplayName: "interface IBar",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForFooInBar2 = new TestInheritanceMemberItem(
                 lineNumber: 12,
@@ -917,11 +896,11 @@ public class {|target5:Bar2|} : Bar1, IBar
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void IBar.Foo()",
                         locationTag: "target6",
-                        relationship: InheritanceRelationship.Implementing),
+                        relationship: InheritanceRelationship.ImplementedMember),
                     new TargetInfo(
                         targetSymbolDisplayName: "virtual void Bar1.Foo()",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Overriding)));
+                        relationship: InheritanceRelationship.OverriddenMember)));
 
             return VerifyInSingleDocumentAsync(
                 testDuplicate ? markup2 : markup1,
@@ -954,7 +933,7 @@ public class {|target1:Bar2|} : IBar<int>, IBar<string>
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class Bar2",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForFooInIBar = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -962,7 +941,7 @@ public class {|target1:Bar2|} : IBar<int>, IBar<string>
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void Bar2.Foo()",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingMember)));
 
             // Only have one IBar<T> item
             var itemForBar2 = new TestInheritanceMemberItem(
@@ -971,7 +950,7 @@ public class {|target1:Bar2|} : IBar<int>, IBar<string>
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "interface IBar<T>",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedInterface)));
 
             // Only have one IBar<T>.Foo item
             var itemForFooInBar2 = new TestInheritanceMemberItem(
@@ -980,7 +959,7 @@ public class {|target1:Bar2|} : IBar<int>, IBar<string>
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void IBar<T>.Foo()",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedMember)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -1013,7 +992,7 @@ abstract class {|target1:AbsBar|} : IBar<int>
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class AbsBar",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForFooInIBar = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -1021,7 +1000,7 @@ abstract class {|target1:AbsBar|} : IBar<int>
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void AbsBar.IBar<int>.Foo(int)",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForAbsBar = new TestInheritanceMemberItem(
                 lineNumber: 7,
@@ -1029,7 +1008,7 @@ abstract class {|target1:AbsBar|} : IBar<int>
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "interface IBar<T>",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForFooInAbsBar = new TestInheritanceMemberItem(
                 lineNumber: 9,
@@ -1037,7 +1016,8 @@ abstract class {|target1:AbsBar|} : IBar<int>
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void IBar<T>.Foo(T)",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedMember)
+                ));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -1048,6 +1028,140 @@ abstract class {|target1:AbsBar|} : IBar<int>
                 itemForFooInAbsBar);
         }
 
+        [Fact]
+        public Task TestStaticAbstractMemberInterface()
+        {
+            var markup = @"
+interface {|target5:I1|}<T> where T : I1<T>
+{
+    static abstract void {|target4:M1|}();
+    static abstract int {|target7:P1|} { get; set; }
+    static abstract event EventHandler {|target9:e1|};
+    static abstract int operator {|target11:+|}(T i1);
+    static abstract implicit operator {|target12:int|}(T i1);
+}
+
+public class {|target1:Class1|} : I1<Class1>
+{
+    public static void {|target2:M1|}() {}
+    public static int {|target6:P1|} { get => 1; set { } }
+    public static event EventHandler {|target8:e1|};
+    public static int operator {|target10:+|}(Class1 i) => 1;
+    public static implicit operator {|target13:int|}(Class1 i) => 0;
+}";
+            var itemForI1 = new TestInheritanceMemberItem(
+                lineNumber: 2,
+                memberName: "interface I1<T>",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "class Class1",
+                        locationTag: "target1",
+                        relationship: InheritanceRelationship.ImplementingType)));
+
+            var itemForM1InI1 = new TestInheritanceMemberItem(
+                lineNumber: 4,
+                memberName: "void I1<T>.M1()",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "static void Class1.M1()",
+                        locationTag: "target2",
+                        relationship: InheritanceRelationship.ImplementingMember)));
+
+            var itemForAbsClass1 = new TestInheritanceMemberItem(
+                lineNumber: 11,
+                memberName: "class Class1",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "interface I1<T>",
+                        locationTag: "target5",
+                        relationship: InheritanceRelationship.ImplementedInterface)));
+
+            var itemForM1InClass1 = new TestInheritanceMemberItem(
+                lineNumber: 13,
+                memberName: "static void Class1.M1()",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "void I1<T>.M1()",
+                        locationTag: "target4",
+                        relationship: InheritanceRelationship.ImplementedMember)));
+
+            var itemForP1InI1 = new TestInheritanceMemberItem(
+                lineNumber: 5,
+                memberName: "int I1<T>.P1 { get; set; }",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "static int Class1.P1 { get; set; }",
+                        locationTag: "target6",
+                        relationship: InheritanceRelationship.ImplementingMember)));
+
+            var itemForP1InClass1 = new TestInheritanceMemberItem(
+                lineNumber: 14,
+                memberName: "static int Class1.P1 { get; set; }",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "int I1<T>.P1 { get; set; }",
+                        locationTag: "target7",
+                        relationship: InheritanceRelationship.ImplementedMember)));
+
+            var itemForE1InI1 = new TestInheritanceMemberItem(
+                lineNumber: 6,
+                memberName: "event EventHandler I1<T>.e1",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "static event EventHandler Class1.e1",
+                        locationTag: "target8",
+                        relationship: InheritanceRelationship.ImplementingMember)));
+
+            var itemForE1InClass1 = new TestInheritanceMemberItem(
+                lineNumber: 15,
+                memberName: "static event EventHandler Class1.e1",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "event EventHandler I1<T>.e1",
+                        locationTag: "target9",
+                        relationship: InheritanceRelationship.ImplementedMember)));
+
+            var itemForPlusOperatorInI1 = new TestInheritanceMemberItem(
+                lineNumber: 7,
+                memberName: "int I1<T>.operator +(T)",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "static int Class1.operator +(Class1)",
+                        locationTag: "target10",
+                        relationship: InheritanceRelationship.ImplementingMember)));
+
+            var itemForPlusOperatorInClass1 = new TestInheritanceMemberItem(
+                lineNumber: 16,
+                memberName: "static int Class1.operator +(Class1)",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "int I1<T>.operator +(T)",
+                        locationTag: "target11",
+                        relationship: InheritanceRelationship.ImplementedMember)));
+
+            var itemForIntOperatorInI1 = new TestInheritanceMemberItem(
+                lineNumber: 8,
+                memberName: "I1<T>.implicit operator int(T)",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "static Class1.implicit operator int(Class1)",
+                        locationTag: "target13",
+                        relationship: InheritanceRelationship.ImplementingMember)));
+
+            var itemForIntOperatorInClass1 = new TestInheritanceMemberItem(
+                lineNumber: 17,
+                memberName: "static Class1.implicit operator int(Class1)",
+                targets: ImmutableArray.Create(new TargetInfo(
+                        targetSymbolDisplayName: "I1<T>.implicit operator int(T)",
+                        locationTag: "target12",
+                        relationship: InheritanceRelationship.ImplementedMember)));
+
+            return VerifyInSingleDocumentAsync(
+                markup,
+                LanguageNames.CSharp,
+                itemForI1,
+                itemForAbsClass1,
+                itemForM1InI1,
+                itemForM1InClass1,
+                itemForP1InI1,
+                itemForP1InClass1,
+                itemForE1InI1,
+                itemForE1InClass1,
+                itemForPlusOperatorInI1,
+                itemForPlusOperatorInClass1,
+                itemForIntOperatorInI1,
+                itemForIntOperatorInClass1);
+        }
+
         #endregion
 
         #region TestsForVisualBasic
@@ -1056,11 +1170,11 @@ abstract class {|target1:AbsBar|} : IBar<int>
         public Task TestVisualBasicWithErrorBaseType()
         {
             var markup = @"
-Namespace MyNamespace
-    Public Class Bar
-        Implements SomethingNotExist
-    End Class
-End Namespace";
+        Namespace MyNamespace
+            Public Class Bar
+                Implements SomethingNotExist
+            End Class
+        End Namespace";
 
             return VerifyNoItemForDocumentAsync(markup, LanguageNames.VisualBasic);
         }
@@ -1069,20 +1183,20 @@ End Class
         public Task TestVisualBasicReferencingMetadata()
         {
             var markup = @"
-Namespace MyNamespace
-    Public Class Bar
-        Implements System.Collections.IEnumerable
-        Public Function GetEnumerator() As System.Collections.IEnumerator Implements System.Collections.IEnumerable.GetEnumerator
-            Throw New NotImplementedException()
-        End Function
-    End Class
-End Namespace";
+        Namespace MyNamespace
+            Public Class Bar
+                Implements System.Collections.IEnumerable
+                Public Function GetEnumerator() As System.Collections.IEnumerator Implements System.Collections.IEnumerable.GetEnumerator
+                    Throw New NotImplementedException()
+                End Function
+            End Class
+        End Namespace";
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 3,
                 memberName: "Class Bar",
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Interface IEnumerable",
-                        relationship: InheritanceRelationship.Implementing,
+                        relationship: InheritanceRelationship.ImplementedInterface,
                         inMetadata: true)));
 
             var itemForGetEnumerator = new TestInheritanceMemberItem(
@@ -1090,7 +1204,7 @@ End Class
                 memberName: "Function Bar.GetEnumerator() As IEnumerator",
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Function IEnumerable.GetEnumerator() As IEnumerator",
-                        relationship: InheritanceRelationship.Implementing,
+                        relationship: InheritanceRelationship.ImplementedMember,
                         inMetadata: true)));
 
             return VerifyInSingleDocumentAsync(markup, LanguageNames.VisualBasic, itemForBar, itemForGetEnumerator);
@@ -1100,18 +1214,18 @@ End Class
         public Task TestVisualBasicClassImplementingInterface()
         {
             var markup = @"
-Interface {|target2:IBar|}
-End Interface
-Class {|target1:Bar|}
-    Implements IBar
-End Class";
+        Interface {|target2:IBar|}
+        End Interface
+        Class {|target1:Bar|}
+            Implements IBar
+        End Class";
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 2,
                 memberName: "Interface IBar",
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Class Bar",
                     locationTag: "target1",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -1119,7 +1233,7 @@ Implements IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Interface IBar",
                     locationTag: "target2",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedInterface)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -1132,11 +1246,11 @@ Implements IBar
         public Task TestVisualBasicInterfaceImplementingInterface()
         {
             var markup = @"
-Interface {|target2:IBar2|}
-End Interface
-Interface {|target1:IBar|}
-    Inherits IBar2
-End Interface";
+        Interface {|target2:IBar2|}
+        End Interface
+        Interface {|target1:IBar|}
+            Inherits IBar2
+        End Interface";
 
             var itemForIBar2 = new TestInheritanceMemberItem(
                 lineNumber: 2,
@@ -1144,7 +1258,7 @@ Inherits IBar2
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Interface IBar",
                     locationTag: "target1",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -1152,7 +1266,7 @@ Inherits IBar2
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Interface IBar2",
                     locationTag: "target2",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.InheritedInterface)));
             return VerifyInSingleDocumentAsync(markup, LanguageNames.VisualBasic, itemForIBar2, itemForIBar);
         }
 
@@ -1160,11 +1274,11 @@ Inherits IBar2
         public Task TestVisualBasicClassInheritsClass()
         {
             var markup = @"
-Class {|target2:Bar2|}
-End Class
-Class {|target1:Bar|}
-    Inherits Bar2
-End Class";
+        Class {|target2:Bar2|}
+        End Class
+        Class {|target1:Bar|}
+            Inherits Bar2
+        End Class";
 
             var itemForBar2 = new TestInheritanceMemberItem(
                 lineNumber: 2,
@@ -1172,7 +1286,7 @@ Inherits Bar2
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Class Bar",
                     locationTag: "target1",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.DerivedType)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -1180,7 +1294,7 @@ Inherits Bar2
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Class Bar2",
                     locationTag: "target2",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.BaseType)));
             return VerifyInSingleDocumentAsync(markup, LanguageNames.VisualBasic, itemForBar2, itemForBar);
         }
 
@@ -1192,8 +1306,8 @@ Inherits Bar2
         public Task TestVisualBasicTypeWithoutBaseType(string typeName)
         {
             var markup = $@"
-{typeName} Bar
-End {typeName}";
+        {typeName} Bar
+        End {typeName}";
 
             return VerifyNoItemForDocumentAsync(markup, LanguageNames.VisualBasic);
         }
@@ -1202,10 +1316,10 @@ public Task TestVisualBasicTypeWithoutBaseType(string typeName)
         public Task TestVisualBasicMetadataInterface()
         {
             var markup = @"
-Imports System.Collections
-Class Bar
-    Implements IEnumerable
-End Class";
+        Imports System.Collections
+        Class Bar
+            Implements IEnumerable
+        End Class";
             return VerifyInSingleDocumentAsync(
                 markup,
                 LanguageNames.VisualBasic,
@@ -1215,7 +1329,7 @@ Implements IEnumerable
                     targets: ImmutableArray.Create(
                         new TargetInfo(
                             targetSymbolDisplayName: "Interface IEnumerable",
-                            relationship: InheritanceRelationship.Implementing,
+                            relationship: InheritanceRelationship.ImplementedInterface,
                             inMetadata: true))));
         }
 
@@ -1223,13 +1337,13 @@ Implements IEnumerable
         public Task TestVisualBasicEventStatement()
         {
             var markup = @"
-Interface {|target2:IBar|}
-    Event {|target4:e|} As EventHandler
-End Interface
-Class {|target1:Bar|}
-    Implements IBar
-    Public Event {|target3:e|} As EventHandler Implements IBar.e
-End Class";
+        Interface {|target2:IBar|}
+            Event {|target4:e|} As EventHandler
+        End Interface
+        Class {|target1:Bar|}
+            Implements IBar
+            Public Event {|target3:e|} As EventHandler Implements IBar.e
+        End Class";
 
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 2,
@@ -1237,7 +1351,7 @@ Implements IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Class Bar",
                     locationTag: "target1",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 5,
@@ -1245,7 +1359,7 @@ Implements IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Interface IBar",
                     locationTag: "target2",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForEventInInterface = new TestInheritanceMemberItem(
                 lineNumber: 3,
@@ -1253,7 +1367,7 @@ Implements IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Event Bar.e As EventHandler",
                     locationTag: "target3",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForEventInClass = new TestInheritanceMemberItem(
                 lineNumber: 7,
@@ -1261,7 +1375,7 @@ Implements IBar
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Event IBar.e As EventHandler",
                     locationTag: "target4",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedMember)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -1276,21 +1390,21 @@ Implements IBar
         public Task TestVisualBasicEventBlock()
         {
             var markup = @"
-Interface {|target2:IBar|}
-    Event {|target4:e|} As EventHandler
-End Interface
-Class {|target1:Bar|}
-    Implements IBar
-    Public Custom Event {|target3:e|} As EventHandler Implements IBar.e
-    End Event
-End Class";
+        Interface {|target2:IBar|}
+            Event {|target4:e|} As EventHandler
+        End Interface
+        Class {|target1:Bar|}
+            Implements IBar
+            Public Custom Event {|target3:e|} As EventHandler Implements IBar.e
+            End Event
+        End Class";
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 2,
                 memberName: "Interface IBar",
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Class Bar",
                     locationTag: "target1",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 5,
@@ -1298,7 +1412,7 @@ End Event
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Interface IBar",
                     locationTag: "target2",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForEventInInterface = new TestInheritanceMemberItem(
                 lineNumber: 3,
@@ -1306,7 +1420,7 @@ End Event
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Event Bar.e As EventHandler",
                     locationTag: "target3",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForEventInClass = new TestInheritanceMemberItem(
                 lineNumber: 7,
@@ -1314,7 +1428,7 @@ End Event
                 ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Event IBar.e As EventHandler",
                     locationTag: "target4",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedMember)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -1329,31 +1443,31 @@ End Event
         public Task TestVisualBasicInterfaceMembers()
         {
             var markup = @"
-Interface {|target2:IBar|}
-    Property {|target4:Poo|} As Integer
-    Function {|target6:Foo|}() As Integer
-End Interface
-
-Class {|target1:Bar|}
-    Implements IBar
-    Public Property {|target3:Poo|} As Integer Implements IBar.Poo
-        Get
-            Return 1
-        End Get
-        Set(value As Integer)
-        End Set
-    End Property
-    Public Function {|target5:Foo|}() As Integer Implements IBar.Foo
-        Return 1
-    End Function
-End Class";
+        Interface {|target2:IBar|}
+            Property {|target4:Poo|} As Integer
+            Function {|target6:Foo|}() As Integer
+        End Interface
+
+        Class {|target1:Bar|}
+            Implements IBar
+            Public Property {|target3:Poo|} As Integer Implements IBar.Poo
+                Get
+                    Return 1
+                End Get
+                Set(value As Integer)
+                End Set
+            End Property
+            Public Function {|target5:Foo|}() As Integer Implements IBar.Foo
+                Return 1
+            End Function
+        End Class";
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 2,
                 memberName: "Interface IBar",
                 targets: ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Class Bar",
                     locationTag: "target1",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 7,
@@ -1361,7 +1475,7 @@ End Function
                 targets: ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Interface IBar",
                     locationTag: "target2",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForPooInInterface = new TestInheritanceMemberItem(
                 lineNumber: 3,
@@ -1369,7 +1483,7 @@ End Function
                 targets: ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Property Bar.Poo As Integer",
                     locationTag: "target3",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForPooInClass = new TestInheritanceMemberItem(
                 lineNumber: 9,
@@ -1377,7 +1491,7 @@ End Function
                 targets: ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Property IBar.Poo As Integer",
                     locationTag: "target4",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedMember)));
 
             var itemForFooInInterface = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -1385,7 +1499,7 @@ End Function
                 targets: ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Function Bar.Foo() As Integer",
                     locationTag: "target5",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForFooInClass = new TestInheritanceMemberItem(
                 lineNumber: 16,
@@ -1393,7 +1507,7 @@ End Function
                 targets: ImmutableArray.Create(new TargetInfo(
                     targetSymbolDisplayName: "Function IBar.Foo() As Integer",
                     locationTag: "target6",
-                    relationship: InheritanceRelationship.Implementing)));
+                    relationship: InheritanceRelationship.ImplementedMember)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -1410,22 +1524,22 @@ End Function
         public Task TestVisualBasicMustInheritClassMember()
         {
             var markup = @"
-MustInherit Class {|target2:Bar1|}
-    Public MustOverride Sub {|target4:Foo|}()
-End Class
-
-Class {|target1:Bar|}
-    Inherits Bar1
-    Public Overrides Sub {|target3:Foo|}()
-    End Sub
-End Class";
+        MustInherit Class {|target2:Bar1|}
+            Public MustOverride Sub {|target4:Foo|}()
+        End Class
+
+        Class {|target1:Bar|}
+            Inherits Bar1
+            Public Overrides Sub {|target3:Foo|}()
+            End Sub
+        End Class";
             var itemForBar1 = new TestInheritanceMemberItem(
                 lineNumber: 2,
                 memberName: "Class Bar1",
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: $"Class Bar",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.DerivedType)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 6,
@@ -1433,7 +1547,7 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Class Bar1",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.BaseType)));
 
             var itemForFooInBar1 = new TestInheritanceMemberItem(
                     lineNumber: 3,
@@ -1441,7 +1555,7 @@ End Sub
                     targets: ImmutableArray.Create(new TargetInfo(
                             targetSymbolDisplayName: "Overrides Sub Bar.Foo()",
                             locationTag: "target3",
-                            relationship: InheritanceRelationship.Overridden)));
+                            relationship: InheritanceRelationship.OverridingMember)));
 
             var itemForFooInBar = new TestInheritanceMemberItem(
                     lineNumber: 8,
@@ -1449,7 +1563,7 @@ End Sub
                     targets: ImmutableArray.Create(new TargetInfo(
                             targetSymbolDisplayName: "MustOverride Sub Bar1.Foo()",
                             locationTag: "target4",
-                            relationship: InheritanceRelationship.Overriding)));
+                            relationship: InheritanceRelationship.OverriddenMember)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -1465,49 +1579,49 @@ End Sub
         public Task TestVisualBasicOverrideMemberCanFindImplementingInterface(bool testDuplicate)
         {
             var markup1 = @"
-Interface {|target4:IBar|}
-    Sub {|target6:Foo|}()
-End Interface
-
-Class {|target1:Bar1|}
-    Implements IBar
-    Public Overridable Sub {|target2:Foo|}() Implements IBar.Foo
-    End Sub
-End Class
-
-Class {|target5:Bar2|}
-    Inherits Bar1
-    Public Overrides Sub {|target3:Foo|}()
-    End Sub
-End Class";
+        Interface {|target4:IBar|}
+            Sub {|target6:Foo|}()
+        End Interface
+
+        Class {|target1:Bar1|}
+            Implements IBar
+            Public Overridable Sub {|target2:Foo|}() Implements IBar.Foo
+            End Sub
+        End Class
+
+        Class {|target5:Bar2|}
+            Inherits Bar1
+            Public Overrides Sub {|target3:Foo|}()
+            End Sub
+        End Class";
 
             var markup2 = @"
-Interface {|target4:IBar|}
-    Sub {|target6:Foo|}()
-End Interface
-
-Class {|target1:Bar1|}
-    Implements IBar
-    Public Overridable Sub {|target2:Foo|}() Implements IBar.Foo
-    End Sub
-End Class
-
-Class {|target5:Bar2|}
-    Inherits Bar1
-    Public Overrides Sub {|target3:Foo|}()
-    End Sub
-End Class";
+        Interface {|target4:IBar|}
+            Sub {|target6:Foo|}()
+        End Interface
+
+        Class {|target1:Bar1|}
+            Implements IBar
+            Public Overridable Sub {|target2:Foo|}() Implements IBar.Foo
+            End Sub
+        End Class
+
+        Class {|target5:Bar2|}
+            Inherits Bar1
+            Public Overrides Sub {|target3:Foo|}()
+            End Sub
+        End Class";
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 2,
                 memberName: "Interface IBar",
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Class Bar1",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implemented),
+                        relationship: InheritanceRelationship.ImplementingType),
                 new TargetInfo(
                     targetSymbolDisplayName: "Class Bar2",
                     locationTag: "target5",
-                    relationship: InheritanceRelationship.Implemented)));
+                    relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForFooInIBar = new TestInheritanceMemberItem(
                 lineNumber: 3,
@@ -1515,11 +1629,11 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Overridable Sub Bar1.Foo()",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implemented),
+                        relationship: InheritanceRelationship.ImplementingMember),
                     new TargetInfo(
                         targetSymbolDisplayName: "Overrides Sub Bar2.Foo()",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForBar1 = new TestInheritanceMemberItem(
                 lineNumber: 6,
@@ -1527,11 +1641,11 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Interface IBar",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Implementing),
+                        relationship: InheritanceRelationship.ImplementedInterface),
                     new TargetInfo(
                         targetSymbolDisplayName: "Class Bar2",
                         locationTag: "target5",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.DerivedType)));
 
             var itemForFooInBar1 = new TestInheritanceMemberItem(
                 lineNumber: 8,
@@ -1539,11 +1653,11 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Sub IBar.Foo()",
                         locationTag: "target6",
-                        relationship: InheritanceRelationship.Implementing),
+                        relationship: InheritanceRelationship.ImplementedMember),
                     new TargetInfo(
                         targetSymbolDisplayName: "Overrides Sub Bar2.Foo()",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Overridden)));
+                        relationship: InheritanceRelationship.OverridingMember)));
 
             var itemForBar2 = new TestInheritanceMemberItem(
                 lineNumber: 12,
@@ -1552,11 +1666,11 @@ End Sub
                     new TargetInfo(
                         targetSymbolDisplayName: "Class Bar1",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implementing),
+                        relationship: InheritanceRelationship.BaseType),
                     new TargetInfo(
                         targetSymbolDisplayName: "Interface IBar",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForFooInBar2 = new TestInheritanceMemberItem(
                 lineNumber: 14,
@@ -1564,11 +1678,11 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Sub IBar.Foo()",
                         locationTag: "target6",
-                        relationship: InheritanceRelationship.Implementing),
+                        relationship: InheritanceRelationship.ImplementedMember),
                     new TargetInfo(
                         targetSymbolDisplayName: "Overridable Sub Bar1.Foo()",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Overriding)));
+                        relationship: InheritanceRelationship.OverriddenMember)));
 
             return VerifyInSingleDocumentAsync(
                 testDuplicate ? markup2 : markup1,
@@ -1585,22 +1699,22 @@ End Sub
         public Task TestVisualBasicFindGenericsBaseType()
         {
             var markup = @"
-Public Interface {|target5:IBar|}(Of T)
-    Sub {|target6:Foo|}()
-End Interface
+        Public Interface {|target5:IBar|}(Of T)
+            Sub {|target6:Foo|}()
+        End Interface
 
-Public Class {|target1:Bar|}
-    Implements IBar(Of Integer)
-    Implements IBar(Of String)
+        Public Class {|target1:Bar|}
+            Implements IBar(Of Integer)
+            Implements IBar(Of String)
 
-    Public Sub {|target3:Foo|}() Implements IBar(Of Integer).Foo
-        Throw New NotImplementedException()
-    End Sub
+            Public Sub {|target3:Foo|}() Implements IBar(Of Integer).Foo
+                Throw New NotImplementedException()
+            End Sub
 
-    Private Sub {|target4:IBar_Foo|}() Implements IBar(Of String).Foo
-        Throw New NotImplementedException()
-    End Sub
-End Class";
+            Private Sub {|target4:IBar_Foo|}() Implements IBar(Of String).Foo
+                Throw New NotImplementedException()
+            End Sub
+        End Class";
 
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 2,
@@ -1608,7 +1722,7 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Class Bar",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForFooInIBar = new TestInheritanceMemberItem(
                 lineNumber: 3,
@@ -1616,11 +1730,11 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Sub Bar.Foo()",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Implemented),
+                        relationship: InheritanceRelationship.ImplementingMember),
                         new TargetInfo(
                             targetSymbolDisplayName: "Sub Bar.IBar_Foo()",
                             locationTag: "target4",
-                            relationship: InheritanceRelationship.Implemented)));
+                            relationship: InheritanceRelationship.ImplementingMember)));
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 6,
@@ -1628,7 +1742,7 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Interface IBar(Of T)",
                         locationTag: "target5",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForFooInBar = new TestInheritanceMemberItem(
                 lineNumber: 10,
@@ -1636,7 +1750,7 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Sub IBar(Of T).Foo()",
                         locationTag: "target6",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedMember)));
 
             var itemForIBar_FooInBar = new TestInheritanceMemberItem(
                 lineNumber: 14,
@@ -1644,7 +1758,7 @@ End Sub
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Sub IBar(Of T).Foo()",
                         locationTag: "target6",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedMember)));
 
             return VerifyInSingleDocumentAsync(
                 markup,
@@ -1662,21 +1776,21 @@ End Sub
         public Task TestCSharpProjectReferencingVisualBasicProject()
         {
             var markup1 = @"
-using MyNamespace;
-namespace BarNs
-{
-    public class {|target2:Bar|} : IBar
-    {
-        public void {|target4:Foo|}() { }
-    }
-}";
+        using MyNamespace;
+        namespace BarNs
+        {
+            public class {|target2:Bar|} : IBar
+            {
+                public void {|target4:Foo|}() { }
+            }
+        }";
 
             var markup2 = @"
-Namespace MyNamespace
-    Public Interface {|target1:IBar|}
-        Sub {|target3:Foo|}()
-    End Interface
-End Namespace";
+        Namespace MyNamespace
+            Public Interface {|target1:IBar|}
+                Sub {|target3:Foo|}()
+            End Interface
+        End Namespace";
 
             var itemForBar = new TestInheritanceMemberItem(
                 lineNumber: 5,
@@ -1684,7 +1798,7 @@ End Interface
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Interface IBar",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForFooInMarkup1 = new TestInheritanceMemberItem(
                 lineNumber: 7,
@@ -1692,7 +1806,7 @@ End Interface
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Sub IBar.Foo()",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedMember)));
 
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 3,
@@ -1700,7 +1814,7 @@ End Interface
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "class Bar",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForFooInMarkup2 = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -1708,7 +1822,7 @@ End Interface
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void Bar.Foo()",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingMember)));
 
             return VerifyInDifferentProjectsAsync(
                 (markup1, LanguageNames.CSharp),
@@ -1721,24 +1835,24 @@ End Interface
         public Task TestVisualBasicProjectReferencingCSharpProject()
         {
             var markup1 = @"
-Imports BarNs
-Namespace MyNamespace
-    Public Class {|target2:Bar44|}
-        Implements IBar
+        Imports BarNs
+        Namespace MyNamespace
+            Public Class {|target2:Bar44|}
+                Implements IBar
 
-        Public Sub {|target4:Foo|}() Implements IBar.Foo
-        End Sub
-    End Class
-End Namespace";
+                Public Sub {|target4:Foo|}() Implements IBar.Foo
+                End Sub
+            End Class
+        End Namespace";
 
             var markup2 = @"
-namespace BarNs
-{
-    public interface {|target1:IBar|}
-    {
-        void {|target3:Foo|}();
-    }
-}";
+        namespace BarNs
+        {
+            public interface {|target1:IBar|}
+            {
+                void {|target3:Foo|}();
+            }
+        }";
 
             var itemForBar44 = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -1746,7 +1860,7 @@ public interface {|target1:IBar|}
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "interface IBar",
                         locationTag: "target1",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedInterface)));
 
             var itemForFooInMarkup1 = new TestInheritanceMemberItem(
                 lineNumber: 7,
@@ -1754,7 +1868,7 @@ public interface {|target1:IBar|}
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "void IBar.Foo()",
                         locationTag: "target3",
-                        relationship: InheritanceRelationship.Implementing)));
+                        relationship: InheritanceRelationship.ImplementedMember)));
 
             var itemForIBar = new TestInheritanceMemberItem(
                 lineNumber: 4,
@@ -1762,7 +1876,7 @@ public interface {|target1:IBar|}
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Class Bar44",
                         locationTag: "target2",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingType)));
 
             var itemForFooInMarkup2 = new TestInheritanceMemberItem(
                 lineNumber: 6,
@@ -1770,7 +1884,7 @@ public interface {|target1:IBar|}
                 targets: ImmutableArray.Create(new TargetInfo(
                         targetSymbolDisplayName: "Sub Bar44.Foo()",
                         locationTag: "target4",
-                        relationship: InheritanceRelationship.Implemented)));
+                        relationship: InheritanceRelationship.ImplementingMember)));
 
             return VerifyInDifferentProjectsAsync(
                 (markup1, LanguageNames.VisualBasic),
diff --git a/src/EditorFeatures/Test/MetadataAsSource/MetadataAsSourceTests.cs b/src/EditorFeatures/Test/MetadataAsSource/MetadataAsSourceTests.cs
index cb59f140b4de9..fc2368f442f1f 100644
--- a/src/EditorFeatures/Test/MetadataAsSource/MetadataAsSourceTests.cs
+++ b/src/EditorFeatures/Test/MetadataAsSource/MetadataAsSourceTests.cs
@@ -3087,5 +3087,33 @@ public class TestType
             var metadataAsSourceFile = await context.GenerateSourceAsync(navigationSymbol);
             TestContext.VerifyResult(metadataAsSourceFile, expected);
         }
+
+        [WorkItem(22431, "https://github.com/dotnet/roslyn/issues/22431")]
+        [Fact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
+        public async Task TestCDATAComment()
+        {
+            var source = @"
+public enum BinaryOperatorKind
+{
+    /// <summary>
+    /// Represents the <![CDATA['<<']]> operator.
+    /// </summary>
+    LeftShift = 0x8,
+}
+";
+            var symbolName = "BinaryOperatorKind.LeftShift";
+            var expectedCS = $@"#region {FeaturesResources.Assembly} ReferencedAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
+// {CodeAnalysisResources.InMemoryAssembly}
+#endregion
+
+public enum BinaryOperatorKind
+{{
+    //
+    // {FeaturesResources.Summary_colon}
+    //     Represents the '<<' operator.
+    [|LeftShift|] = 8
+}}";
+            await GenerateAndVerifySourceAsync(source, symbolName, LanguageNames.CSharp, expectedCS, includeXmlDocComments: true);
+        }
     }
 }
diff --git a/src/EditorFeatures/Test/SolutionCrawler/WorkCoordinatorTests.cs b/src/EditorFeatures/Test/SolutionCrawler/WorkCoordinatorTests.cs
index 14eb9c357849b..3ecd69d10d544 100644
--- a/src/EditorFeatures/Test/SolutionCrawler/WorkCoordinatorTests.cs
+++ b/src/EditorFeatures/Test/SolutionCrawler/WorkCoordinatorTests.cs
@@ -788,14 +788,23 @@ internal async Task Document_Cancellation(BackgroundAnalysisScope analysisScope,
             var expectedDocumentSyntaxEvents = 1;
             var expectedDocumentSemanticEvents = 5;
 
+            var listenerProvider = GetListenerProvider(workspace.ExportProvider);
+
+            // start an operation that allows an expedited wait to cover the remainder of the delayed operations in the test
+            var token = listenerProvider.GetListener(FeatureAttribute.SolutionCrawler).BeginAsyncOperation("Test operation");
+            var expeditedWait = listenerProvider.GetWaiter(FeatureAttribute.SolutionCrawler).ExpeditedWaitAsync();
+
             workspace.ChangeDocument(document.Id, SourceText.From("//"));
             if (expectedDocumentSyntaxEvents > 0 || expectedDocumentSemanticEvents > 0)
             {
                 analyzer.RunningEvent.Wait();
             }
 
+            token.Dispose();
+
             workspace.ChangeDocument(document.Id, SourceText.From("// "));
             await WaitAsync(service, workspace);
+            await expeditedWait;
 
             service.Unregister(workspace);
 
@@ -833,6 +842,12 @@ internal async Task Document_Cancellation_MultipleTimes(BackgroundAnalysisScope
 
             service.Register(workspace);
 
+            var listenerProvider = GetListenerProvider(workspace.ExportProvider);
+
+            // start an operation that allows an expedited wait to cover the remainder of the delayed operations in the test
+            var token = listenerProvider.GetListener(FeatureAttribute.SolutionCrawler).BeginAsyncOperation("Test operation");
+            var expeditedWait = listenerProvider.GetWaiter(FeatureAttribute.SolutionCrawler).ExpeditedWaitAsync();
+
             workspace.ChangeDocument(document.Id, SourceText.From("//"));
             if (expectedDocumentSyntaxEvents > 0 || expectedDocumentSemanticEvents > 0)
             {
@@ -846,8 +861,11 @@ internal async Task Document_Cancellation_MultipleTimes(BackgroundAnalysisScope
                 analyzer.RunningEvent.Wait();
             }
 
+            token.Dispose();
+
             workspace.ChangeDocument(document.Id, SourceText.From("//  "));
             await WaitAsync(service, workspace);
+            await expeditedWait;
 
             service.Unregister(workspace);
 
@@ -1273,6 +1291,12 @@ public async Task FileFromSameProjectTogetherTest()
 
             await WaitWaiterAsync(workspace.ExportProvider);
 
+            var listenerProvider = GetListenerProvider(workspace.ExportProvider);
+
+            // start an operation that allows an expedited wait to cover the remainder of the delayed operations in the test
+            var token = listenerProvider.GetListener(FeatureAttribute.SolutionCrawler).BeginAsyncOperation("Test operation");
+            var expeditedWait = listenerProvider.GetWaiter(FeatureAttribute.SolutionCrawler).ExpeditedWaitAsync();
+
             // we want to test order items processed by solution crawler.
             // but since everything async, lazy and cancellable, order is not 100% deterministic. an item might 
             // start to be processed, and get cancelled due to newly enqueued item requiring current work to be re-processed 
@@ -1319,8 +1343,11 @@ await crawlerListener.WaitUntilConditionIsMetAsync(
                 operation.Done();
             }
 
+            token.Dispose();
+
             // wait analyzers to finish process
             await WaitAsync(service, workspace);
+            await expeditedWait;
 
             Assert.Equal(1, worker.DocumentIds.Take(5).Select(d => d.ProjectId).Distinct().Count());
             Assert.Equal(1, worker.DocumentIds.Skip(5).Take(5).Select(d => d.ProjectId).Distinct().Count());
@@ -1339,7 +1366,6 @@ private static async Task InsertText(string code, string text, bool expectDocume
                 composition: EditorTestCompositions.EditorFeatures.AddExcludedPartTypes(typeof(IIncrementalAnalyzerProvider)).AddParts(typeof(AnalyzerProviderNoWaitNoBlock)),
                 workspaceKind: SolutionCrawlerWorkspaceKind);
 
-            SetOptions(workspace);
             var testDocument = workspace.Documents.First();
             var textBuffer = testDocument.GetTextBuffer();
 
@@ -1476,18 +1502,6 @@ private static IEnumerable<DocumentInfo> GetDocuments(ProjectId projectId, int c
         private static AsynchronousOperationListenerProvider GetListenerProvider(ExportProvider provider)
             => provider.GetExportedValue<AsynchronousOperationListenerProvider>();
 
-        private static void SetOptions(Workspace workspace)
-        {
-            // override default timespan to make test run faster
-            workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                                                 .WithChangedOption(InternalSolutionCrawlerOptions.ActiveFileWorkerBackOffTimeSpanInMS, 0)
-                                                 .WithChangedOption(InternalSolutionCrawlerOptions.AllFilesWorkerBackOffTimeSpanInMS, 0)
-                                                 .WithChangedOption(InternalSolutionCrawlerOptions.PreviewBackOffTimeSpanInMS, 0)
-                                                 .WithChangedOption(InternalSolutionCrawlerOptions.ProjectPropagationBackOffTimeSpanInMS, 0)
-                                                 .WithChangedOption(InternalSolutionCrawlerOptions.SemanticChangeBackOffTimeSpanInMS, 0)
-                                                 .WithChangedOption(InternalSolutionCrawlerOptions.EntireProjectWorkerBackOffTimeSpanInMS, 100)));
-        }
-
         private static void MakeFirstDocumentActive(Project project)
             => MakeDocumentActive(project.Documents.First());
 
@@ -1518,8 +1532,6 @@ public WorkCoordinatorWorkspace(string workspaceKind = null, bool disablePartial
 
                 Assert.False(_workspaceWaiter.HasPendingWork);
                 Assert.False(_solutionCrawlerWaiter.HasPendingWork);
-
-                WorkCoordinatorTests.SetOptions(this);
             }
 
             public static WorkCoordinatorWorkspace CreateWithAnalysisScope(BackgroundAnalysisScope analysisScope, string workspaceKind = null, bool disablePartialSolutions = true, Type incrementalAnalyzer = null)
diff --git a/src/EditorFeatures/Test/Structure/StructureTaggerTests.cs b/src/EditorFeatures/Test/Structure/StructureTaggerTests.cs
index a1e78c1c09379..f3fa70ebc6c54 100644
--- a/src/EditorFeatures/Test/Structure/StructureTaggerTests.cs
+++ b/src/EditorFeatures/Test/Structure/StructureTaggerTests.cs
@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Structure;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.VisualStudio.Text.Adornments;
 using Microsoft.VisualStudio.Text.Tagging;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
@@ -25,7 +26,10 @@ public class StructureTaggerTests
     {
         [WpfTheory, Trait(Traits.Feature, Traits.Features.Outlining)]
         [CombinatorialData]
-        public async Task CSharpOutliningTagger(bool collapseRegionsWhenCollapsingToDefinitions)
+        public async Task CSharpOutliningTagger(
+            bool collapseRegionsWhenCollapsingToDefinitions,
+            bool showBlockStructureGuidesForDeclarationLevelConstructs,
+            bool showBlockStructureGuidesForCodeLevelConstructs)
         {
             var code =
 @"using System;
@@ -36,6 +40,11 @@ public class MyClass
     {
         static void Main(string[] args)
         {
+            if (false)
+            {
+                return;
+            }
+
             int x = 5;
         }
     }
@@ -44,7 +53,9 @@ static void Main(string[] args)
 
             using var workspace = TestWorkspace.CreateCSharp(code, composition: EditorTestCompositions.EditorFeaturesWpf);
             workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                .WithChangedOption(BlockStructureOptions.CollapseRegionsWhenCollapsingToDefinitions, LanguageNames.CSharp, collapseRegionsWhenCollapsingToDefinitions)));
+                .WithChangedOption(BlockStructureOptions.CollapseRegionsWhenCollapsingToDefinitions, LanguageNames.CSharp, collapseRegionsWhenCollapsingToDefinitions)
+                .WithChangedOption(BlockStructureOptions.ShowBlockStructureGuidesForDeclarationLevelConstructs, LanguageNames.CSharp, showBlockStructureGuidesForDeclarationLevelConstructs)
+                .WithChangedOption(BlockStructureOptions.ShowBlockStructureGuidesForCodeLevelConstructs, LanguageNames.CSharp, showBlockStructureGuidesForCodeLevelConstructs)));
 
             var tags = await GetTagsFromWorkspaceAsync(workspace);
 
@@ -52,37 +63,56 @@ static void Main(string[] args)
                 namespaceTag =>
                 {
                     Assert.False(namespaceTag.IsImplementation);
-                    Assert.Equal(12, GetCollapsedHintLineCount(namespaceTag));
+                    Assert.Equal(17, GetCollapsedHintLineCount(namespaceTag));
+                    Assert.Equal(showBlockStructureGuidesForDeclarationLevelConstructs ? PredefinedStructureTagTypes.Namespace : PredefinedStructureTagTypes.Nonstructural, namespaceTag.Type);
                     Assert.Equal("namespace MyNamespace", GetHeaderText(namespaceTag));
                 },
                 regionTag =>
                 {
                     Assert.Equal(collapseRegionsWhenCollapsingToDefinitions, regionTag.IsImplementation);
-                    Assert.Equal(9, GetCollapsedHintLineCount(regionTag));
+                    Assert.Equal(14, GetCollapsedHintLineCount(regionTag));
+                    Assert.Equal(PredefinedStructureTagTypes.Nonstructural, regionTag.Type);
                     Assert.Equal("#region MyRegion", GetHeaderText(regionTag));
                 },
                 classTag =>
                 {
                     Assert.False(classTag.IsImplementation);
-                    Assert.Equal(7, GetCollapsedHintLineCount(classTag));
+                    Assert.Equal(12, GetCollapsedHintLineCount(classTag));
+                    Assert.Equal(showBlockStructureGuidesForDeclarationLevelConstructs ? PredefinedStructureTagTypes.Type : PredefinedStructureTagTypes.Nonstructural, classTag.Type);
                     Assert.Equal("public class MyClass", GetHeaderText(classTag));
                 },
                 methodTag =>
                 {
                     Assert.True(methodTag.IsImplementation);
-                    Assert.Equal(4, GetCollapsedHintLineCount(methodTag));
+                    Assert.Equal(9, GetCollapsedHintLineCount(methodTag));
+                    Assert.Equal(showBlockStructureGuidesForDeclarationLevelConstructs ? PredefinedStructureTagTypes.Member : PredefinedStructureTagTypes.Nonstructural, methodTag.Type);
                     Assert.Equal("static void Main(string[] args)", GetHeaderText(methodTag));
+                },
+                ifTag =>
+                {
+                    Assert.False(ifTag.IsImplementation);
+                    Assert.Equal(4, GetCollapsedHintLineCount(ifTag));
+                    Assert.Equal(showBlockStructureGuidesForCodeLevelConstructs ? PredefinedStructureTagTypes.Conditional : PredefinedStructureTagTypes.Nonstructural, ifTag.Type);
+                    Assert.Equal("if (false)", GetHeaderText(ifTag));
                 });
         }
 
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
-        public async Task VisualBasicOutliningTagger()
+        [WpfTheory, Trait(Traits.Feature, Traits.Features.Outlining)]
+        [CombinatorialData]
+        public async Task VisualBasicOutliningTagger(
+            bool collapseRegionsWhenCollapsingToDefinitions,
+            bool showBlockStructureGuidesForDeclarationLevelConstructs,
+            bool showBlockStructureGuidesForCodeLevelConstructs)
         {
             var code = @"Imports System
 Namespace MyNamespace
 #Region ""MyRegion""
     Module M
         Sub Main(args As String())
+            If False Then
+                Return
+            End If
+
             Dim x As Integer = 5
         End Sub
     End Module
@@ -90,32 +120,48 @@ End Module
 End Namespace";
 
             using var workspace = TestWorkspace.CreateVisualBasic(code, composition: EditorTestCompositions.EditorFeaturesWpf);
+            workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
+                .WithChangedOption(BlockStructureOptions.CollapseRegionsWhenCollapsingToDefinitions, LanguageNames.VisualBasic, collapseRegionsWhenCollapsingToDefinitions)
+                .WithChangedOption(BlockStructureOptions.ShowBlockStructureGuidesForDeclarationLevelConstructs, LanguageNames.VisualBasic, showBlockStructureGuidesForDeclarationLevelConstructs)
+                .WithChangedOption(BlockStructureOptions.ShowBlockStructureGuidesForCodeLevelConstructs, LanguageNames.VisualBasic, showBlockStructureGuidesForCodeLevelConstructs)));
+
             var tags = await GetTagsFromWorkspaceAsync(workspace);
 
             Assert.Collection(tags,
                 namespaceTag =>
                 {
                     Assert.False(namespaceTag.IsImplementation);
-                    Assert.Equal(9, GetCollapsedHintLineCount(namespaceTag));
+                    Assert.Equal(13, GetCollapsedHintLineCount(namespaceTag));
+                    Assert.Equal(showBlockStructureGuidesForDeclarationLevelConstructs ? PredefinedStructureTagTypes.Namespace : PredefinedStructureTagTypes.Nonstructural, namespaceTag.Type);
                     Assert.Equal("Namespace MyNamespace", GetHeaderText(namespaceTag));
                 },
                 regionTag =>
                 {
-                    Assert.False(regionTag.IsImplementation);
-                    Assert.Equal(7, GetCollapsedHintLineCount(regionTag));
+                    Assert.Equal(collapseRegionsWhenCollapsingToDefinitions, regionTag.IsImplementation);
+                    Assert.Equal(11, GetCollapsedHintLineCount(regionTag));
+                    Assert.Equal(PredefinedStructureTagTypes.Nonstructural, regionTag.Type);
                     Assert.Equal(@"#Region ""MyRegion""", GetHeaderText(regionTag));
                 },
                 moduleTag =>
                 {
                     Assert.False(moduleTag.IsImplementation);
-                    Assert.Equal(5, GetCollapsedHintLineCount(moduleTag));
+                    Assert.Equal(9, GetCollapsedHintLineCount(moduleTag));
+                    Assert.Equal(showBlockStructureGuidesForDeclarationLevelConstructs ? PredefinedStructureTagTypes.Type : PredefinedStructureTagTypes.Nonstructural, moduleTag.Type);
                     Assert.Equal("Module M", GetHeaderText(moduleTag));
                 },
                 methodTag =>
                 {
                     Assert.True(methodTag.IsImplementation);
-                    Assert.Equal(3, GetCollapsedHintLineCount(methodTag));
+                    Assert.Equal(7, GetCollapsedHintLineCount(methodTag));
+                    Assert.Equal(showBlockStructureGuidesForDeclarationLevelConstructs ? PredefinedStructureTagTypes.Member : PredefinedStructureTagTypes.Nonstructural, methodTag.Type);
                     Assert.Equal("Sub Main(args As String())", GetHeaderText(methodTag));
+                },
+                ifTag =>
+                {
+                    Assert.False(ifTag.IsImplementation);
+                    Assert.Equal(3, GetCollapsedHintLineCount(ifTag));
+                    Assert.Equal(showBlockStructureGuidesForCodeLevelConstructs ? PredefinedStructureTagTypes.Conditional : PredefinedStructureTagTypes.Nonstructural, ifTag.Type);
+                    Assert.Equal("If False Then", GetHeaderText(ifTag));
                 });
 
         }
diff --git a/src/EditorFeatures/Test/UnusedReferences/UnusedReferencesRemoverTests.cs b/src/EditorFeatures/Test/UnusedReferences/UnusedReferencesRemoverTests.cs
index 3e1b569e0b6ee..b7cadd79d5097 100644
--- a/src/EditorFeatures/Test/UnusedReferences/UnusedReferencesRemoverTests.cs
+++ b/src/EditorFeatures/Test/UnusedReferences/UnusedReferencesRemoverTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.IO;
@@ -15,16 +16,42 @@ namespace Microsoft.CodeAnalysis.Editor.UnitTests.UnusedReferences
 {
     public class UnusedReferencesRemoverTests
     {
-        private const string UsedAssemblyPath = "/libs/Used.dll";
-        private const string UnusedAssemblyPath = "/libs/Unused.dll";
+        private static readonly string[] Empty = Array.Empty<string>();
+
+        private const string UsedAssemblyName = "Used.dll";
+        private const string UsedAssemblyPath = $"/libs/{UsedAssemblyName}";
+        private const string UnusedAssemblyName = "Unused.dll";
+        private const string UnusedAssemblyPath = $"/libs/{UnusedAssemblyName}";
 
         [Fact, Trait(Traits.Feature, Traits.Features.UnusedReferences)]
-        public void GetUnusedReferences_UsedReferences_AreNotReturned()
+        public void GetUnusedReferences_DirectlyUsedAssemblyReferences_AreNotReturned()
         {
             var usedAssemblies = new[] { UsedAssemblyPath };
             var usedReference = AssemblyReference(UsedAssemblyPath);
 
-            var unusedReferences = GetUnusedReferences(usedAssemblies, usedReference);
+            var unusedReferences = GetUnusedReferences(usedAssemblies, usedProjectAssemblyNames: Empty, usedReference);
+
+            Assert.Empty(unusedReferences);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.UnusedReferences)]
+        public void GetUnusedReferences_DirectlyUsedPackageReferences_AreNotReturned()
+        {
+            var usedAssemblies = new[] { UsedAssemblyPath };
+            var usedReference = PackageReference(UsedAssemblyPath);
+
+            var unusedReferences = GetUnusedReferences(usedAssemblies, usedProjectAssemblyNames: Empty, usedReference);
+
+            Assert.Empty(unusedReferences);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.UnusedReferences)]
+        public void GetUnusedReferences_DirectlyUsedProjectReferences_AreNotReturned()
+        {
+            var usedProjects = new[] { UsedAssemblyName };
+            var usedReference = ProjectReference(UsedAssemblyName);
+
+            var unusedReferences = GetUnusedReferences(usedCompilationAssemblies: Empty, usedProjects, usedReference);
 
             Assert.Empty(unusedReferences);
         }
@@ -35,19 +62,30 @@ public void GetUnusedReferences_UnusedReferences_AreReturned()
             var usedAssemblies = new[] { UsedAssemblyPath };
             var unusedReference = PackageReference(UnusedAssemblyPath);
 
-            var unusedReferences = GetUnusedReferences(usedAssemblies, unusedReference);
+            var unusedReferences = GetUnusedReferences(usedAssemblies, usedProjectAssemblyNames: Empty, unusedReference);
 
             Assert.Contains(unusedReference, unusedReferences);
             Assert.Single(unusedReferences);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.UnusedReferences)]
-        public void GetUnusedReferences_TransitivelyUsedReferences_AreNotReturned()
+        public void GetUnusedReferences_TransitivelyUsedPackageReferences_AreNotReturned()
         {
             var usedAssemblies = new[] { UsedAssemblyPath };
-            var transitivelyUsedReference = ProjectReference(UnusedAssemblyPath, PackageReference(UsedAssemblyPath));
+            var transitivelyUsedReference = PackageReference(UnusedAssemblyName, PackageReference(UsedAssemblyPath));
+
+            var unusedReferences = GetUnusedReferences(usedAssemblies, usedProjectAssemblyNames: Empty, transitivelyUsedReference);
+
+            Assert.Empty(unusedReferences);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.UnusedReferences)]
+        public void GetUnusedReferences_TransitivelyUsedProjectReferences_AreNotReturned()
+        {
+            var usedAssemblies = new[] { UsedAssemblyPath };
+            var transitivelyUsedReference = ProjectReference(UnusedAssemblyName, PackageReference(UsedAssemblyPath));
 
-            var unusedReferences = GetUnusedReferences(usedAssemblies, transitivelyUsedReference);
+            var unusedReferences = GetUnusedReferences(usedAssemblies, usedProjectAssemblyNames: Empty, transitivelyUsedReference);
 
             Assert.Empty(unusedReferences);
         }
@@ -59,7 +97,7 @@ public void GetUnusedReferences_WhenUsedAssemblyIsAvilableDirectlyAndTransitivel
             var transitivelyUsedReference = ProjectReference(UnusedAssemblyPath, PackageReference(UsedAssemblyPath));
             var directlyUsedReference = PackageReference(UsedAssemblyPath);
 
-            var unusedReferences = GetUnusedReferences(usedAssemblies, transitivelyUsedReference, directlyUsedReference);
+            var unusedReferences = GetUnusedReferences(usedAssemblies, usedProjectAssemblyNames: Empty, transitivelyUsedReference, directlyUsedReference);
 
             Assert.Contains(transitivelyUsedReference, unusedReferences);
             Assert.Single(unusedReferences);
@@ -76,7 +114,7 @@ public void GetUnusedReferences_ReferencesThatDoNotContributeToCompilation_AreNo
                 compilationAssemblies: ImmutableArray<string>.Empty,
                 dependencies: ImmutableArray<ReferenceInfo>.Empty);
 
-            var unusedReferences = GetUnusedReferences(usedAssemblies, analyzerReference);
+            var unusedReferences = GetUnusedReferences(usedAssemblies, usedProjectAssemblyNames: Empty, analyzerReference);
 
             Assert.Empty(unusedReferences);
         }
@@ -122,8 +160,8 @@ public async Task ApplyReferenceUpdates_MixOfChangeAndNoChangeUpdates_ChangesAre
             Assert.Single(appliedUpdates);
         }
 
-        private static ImmutableArray<ReferenceInfo> GetUnusedReferences(string[] usedCompilationAssemblies, params ReferenceInfo[] references)
-            => UnusedReferencesRemover.GetUnusedReferences(new(usedCompilationAssemblies), references.ToImmutableArray());
+        private static ImmutableArray<ReferenceInfo> GetUnusedReferences(string[] usedCompilationAssemblies, string[] usedProjectAssemblyNames, params ReferenceInfo[] references)
+            => UnusedReferencesRemover.GetUnusedReferences(new(usedCompilationAssemblies), new(usedProjectAssemblyNames), references.ToImmutableArray());
 
         private static async Task<ImmutableArray<ReferenceUpdate>> ApplyReferenceUpdatesAsync(params ReferenceUpdate[] referenceUpdates)
         {
diff --git a/src/EditorFeatures/Test/ValueTracking/AbstractBaseValueTrackingTests.cs b/src/EditorFeatures/Test/ValueTracking/AbstractBaseValueTrackingTests.cs
new file mode 100644
index 0000000000000..549ff737d21ef
--- /dev/null
+++ b/src/EditorFeatures/Test/ValueTracking/AbstractBaseValueTrackingTests.cs
@@ -0,0 +1,94 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.ValueTracking;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Remote.Testing;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using System.Threading;
+using Microsoft.CodeAnalysis.Text;
+using Xunit;
+using System.Collections.Generic;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests.ValueTracking
+{
+    public abstract class AbstractBaseValueTrackingTests
+    {
+        protected TestWorkspace CreateWorkspace(string code, TestHost testHost)
+            => CreateWorkspace(code, EditorTestCompositions.EditorFeatures.WithTestHostParts(testHost));
+
+        protected abstract TestWorkspace CreateWorkspace(string code, TestComposition composition);
+
+        internal static async Task<ImmutableArray<ValueTrackedItem>> GetTrackedItemsAsync(TestWorkspace testWorkspace, CancellationToken cancellationToken = default)
+        {
+            var cursorDocument = testWorkspace.DocumentWithCursor;
+            var document = testWorkspace.CurrentSolution.GetRequiredDocument(cursorDocument.Id);
+            var textSpan = new TextSpan(cursorDocument.CursorPosition!.Value, 0);
+            var service = testWorkspace.Services.GetRequiredService<IValueTrackingService>();
+            return await service.TrackValueSourceAsync(textSpan, document, cancellationToken);
+
+        }
+
+        internal static async Task<ImmutableArray<ValueTrackedItem>> GetTrackedItemsAsync(TestWorkspace testWorkspace, ValueTrackedItem item, CancellationToken cancellationToken = default)
+        {
+            var service = testWorkspace.Services.GetRequiredService<IValueTrackingService>();
+            return await service.TrackValueSourceAsync(testWorkspace.CurrentSolution, item, cancellationToken);
+        }
+
+        internal static async Task<ImmutableArray<ValueTrackedItem>> ValidateItemsAsync(TestWorkspace testWorkspace, (int line, string text)[] itemInfo, CancellationToken cancellationToken = default)
+        {
+            var items = await GetTrackedItemsAsync(testWorkspace, cancellationToken);
+            Assert.True(itemInfo.Length == items.Length, $"GetTrackedItemsAsync\n\texpected: [{string.Join(",", itemInfo.Select(p => p.text))}]\n\t  actual: [{string.Join(",", items)}]");
+
+            for (var i = 0; i < items.Length; i++)
+            {
+                ValidateItem(items[i], itemInfo[i].line, itemInfo[i].text);
+            }
+
+            return items;
+        }
+
+        internal static async Task<ImmutableArray<ValueTrackedItem>> ValidateChildrenAsync(TestWorkspace testWorkspace, ValueTrackedItem item, (int line, string text)[] childInfo, CancellationToken cancellationToken = default)
+        {
+            var children = await GetTrackedItemsAsync(testWorkspace, item, cancellationToken);
+            Assert.True(childInfo.Length == children.Length, $"GetTrackedItemsAsync on [{item}]\n\texpected: [{string.Join(",", childInfo.Select(p => p.text))}]\n\t  actual: [{string.Join(",", children)}]");
+
+            for (var i = 0; i < childInfo.Length; i++)
+            {
+                ValidateItem(children[i], childInfo[i].line, childInfo[i].text);
+            }
+
+            return children;
+        }
+
+        internal static async Task ValidateChildrenEmptyAsync(TestWorkspace testWorkspace, ValueTrackedItem item, CancellationToken cancellationToken = default)
+        {
+            var children = await GetTrackedItemsAsync(testWorkspace, item, cancellationToken);
+            Assert.Empty(children);
+        }
+
+        internal static async Task ValidateChildrenEmptyAsync(TestWorkspace testWorkspace, IEnumerable<ValueTrackedItem> items, CancellationToken cancellationToken = default)
+        {
+            foreach (var item in items)
+            {
+                await ValidateChildrenEmptyAsync(testWorkspace, item, cancellationToken);
+            }
+        }
+
+        internal static void ValidateItem(ValueTrackedItem item, int line, string? text = null)
+        {
+            item.SourceText.GetLineAndOffset(item.Span.Start, out var lineStart, out var _);
+            Assert.Equal(line, lineStart);
+
+            if (text is not null)
+            {
+                Assert.Equal(text, item.ToString());
+            }
+        }
+    }
+}
diff --git a/src/EditorFeatures/Test/ValueTracking/CSharpValueTrackingTests.cs b/src/EditorFeatures/Test/ValueTracking/CSharpValueTrackingTests.cs
new file mode 100644
index 0000000000000..a738d4c001c52
--- /dev/null
+++ b/src/EditorFeatures/Test/ValueTracking/CSharpValueTrackingTests.cs
@@ -0,0 +1,963 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Remote.Testing;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests.ValueTracking
+{
+    [UseExportProvider]
+    public class CSharpValueTrackingTests : AbstractBaseValueTrackingTests
+    {
+        protected override TestWorkspace CreateWorkspace(string code, TestComposition composition)
+            => TestWorkspace.CreateCSharp(code, composition: composition);
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestProperty(TestHost testHost)
+        {
+            var code =
+@"
+class C
+{
+    public string $$S { get; set; } = """""";
+
+    public void SetS(string s)
+    {
+        S = s;
+    }
+
+    public string GetS() => S;
+}
+";
+            using var workspace = CreateWorkspace(code, testHost);
+
+            //
+            // property S 
+            //  |> S = s [Code.cs:7]
+            //  |> public string S { get; set; } [Code.cs:3]
+            //
+            await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (7, "s"),
+                    (3, "public string S { get; set; } = \"\""),
+                });
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestPropertyWithThis(TestHost testHost)
+        {
+            var code =
+@"
+class C
+{
+    public string $$S { get; set; } = """""";
+
+    public void SetS(string s)
+    {
+        this.S = s;
+    }
+
+    public string GetS() => this.S;
+}
+";
+            using var workspace = CreateWorkspace(code, testHost);
+
+            //
+            // property S 
+            //  |> S = s [Code.cs:7]
+            //  |> public string S { get; set; } [Code.cs:3]
+            //
+            await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (7, "s"),
+                    (3, "public string S { get; set; } = \"\""),
+                });
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestField(TestHost testHost)
+        {
+            var code =
+@"
+class C
+{
+    private string $$_s = """""";
+
+    public void SetS(string s)
+    {
+        _s = s;
+    }
+
+    public string GetS() => _s;
+}";
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // field _s 
+            //  |> _s = s [Code.cs:7]
+            //  |> string _s = "" [Code.cs:3]
+            //
+            await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (7, "s"),
+                    (3, "_s = \"\"")
+                });
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestFieldWithThis(TestHost testHost)
+        {
+            var code =
+@"
+class C
+{
+    private string $$_s = """""";
+
+    public void SetS(string s)
+    {
+        this._s = s;
+    }
+
+    public string GetS() => this._s;
+}";
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // field _s 
+            //  |> this._s = s [Code.cs:7]
+            //  |> string _s = "" [Code.cs:3]
+            //
+            await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (7, "s"),
+                    (3, "_s = \"\"")
+                });
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestLocal(TestHost testHost)
+        {
+            var code =
+@"
+class C
+{
+    public int Add(int x, int y)
+    {
+        var $$z = x;
+        z += y;
+        return z;
+    }
+}";
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // local variable z
+            //  |> z += y [Code.cs:6]
+            //  |> var z = x [Code.cs:5]
+            //
+            Assert.Equal(2, initialItems.Length);
+            ValidateItem(initialItems[0], 6);
+            ValidateItem(initialItems[1], 5);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestParameter(TestHost testHost)
+        {
+            var code =
+@"
+class C
+{
+    public int Add(int $$x, int y)
+    {
+        x += y;
+        return x;
+    }
+}";
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // parameter x 
+            //  |> x += y [Code.cs:5]
+            //  |> Add(int x, int y) [Code.cs:3]
+            //
+            Assert.Equal(2, initialItems.Length);
+            ValidateItem(initialItems[0], 5);
+            ValidateItem(initialItems[1], 3);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestMissingOnMethod(TestHost testHost)
+        {
+            var code =
+@"
+class C
+{
+    public int $$Add(int x, int y)
+    {
+        x += y;
+        return x;
+    }
+}";
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+            Assert.Empty(initialItems);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestMissingOnClass(TestHost testHost)
+        {
+            var code =
+@"
+class $$C
+{
+    public int Add(int x, int y)
+    {
+        x += y;
+        return x;
+    }
+}";
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+            Assert.Empty(initialItems);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestMissingOnNamespace(TestHost testHost)
+        {
+            var code =
+@"
+namespace $$N
+{
+    class C
+    {
+        public int Add(int x, int y)
+        {
+            x += y;
+            return x;
+        }
+    }
+}";
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+            Assert.Empty(initialItems);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task MethodTracking1(TestHost testHost)
+        {
+            var code =
+@"
+class C
+{
+    public string S { get; set; } = """""";
+
+    public void SetS(string s)
+    {
+        S$$ = s;
+    }
+
+    public string GetS() => S;
+}
+
+class Other
+{
+    public void CallS(C c, string str)
+    {
+        c.SetS(str);
+    }
+
+    public void CallS(C c)
+    {
+        CallS(c, CalculateDefault(c));
+    }
+
+    private string CalculateDefault(C c)
+    {
+        if (c is null)
+        {
+            return ""null"";
+        }
+
+        if (string.IsNullOrEmpty(c.S))
+        {
+            return ""defaultstring"";
+        }
+
+        return """";
+    }
+}
+";
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // S = s; [Code.cs:7]
+            //  |> S = [|s|] [Code.cs:7]
+            //    |> [|c.SetS(str)|]; [Code.cs:17]
+            //    |> c.SetS([|str|]); [Code.cs:17]
+            //      |> CallS([|c|], CalculateDefault(c)) [Code.cs:22]
+            //      |> CallS(c, [|CalculateDefault(c)|]) [Code.cs:22]
+            //         |>  return "" [Code.cs:37]
+            //         |>  return "defaultstring" [Code.cs:34]
+            //         |> return "null" [Code.cs:29]
+            // 
+            Assert.Equal(1, initialItems.Length);
+            ValidateItem(initialItems[0], 7);
+
+            var items = await ValidateChildrenAsync(
+                workspace,
+                initialItems.Single(),
+                childInfo: new[]
+                {
+                    (17, "str"), // |> c.SetS([|str|]); [Code.cs:17]
+                    (17, "c.SetS(str)"), // |> [|c.SetS(str)|]; [Code.cs:17]
+                });
+
+            // |> [|c.SetS(s)|]; [Code.cs:17]
+            await ValidateChildrenEmptyAsync(workspace, items[1]);
+
+            // |> c.SetS([|s|]); [Code.cs:17]
+            items = await ValidateChildrenAsync(
+                workspace,
+                items[0],
+                childInfo: new[]
+                {
+                    (22, "c" ), // |> CallS([|c|], CalculateDefault(c)) [Code.cs:22]
+                    (22, "c" ), // |> CallS(c, CalculateDefault([|c|])) [Code.cs:22]
+                    (22, "CalculateDefault(c)" ), // |> CallS(c, [|CalculateDefault(c)|]) [Code.cs:22]
+                    (22, "CallS(c, CalculateDefault(c))" ) // |> [|CallS(c, CalculateDefault(c))|] [Code.cs:22]
+                });
+
+            // |> CallS([|c|], CalculateDefault(c)) [Code.cs:22]
+            await ValidateChildrenEmptyAsync(workspace, items[0]);
+            // |> CallS(c, CalculateDefault([|c|])) [Code.cs:22]
+            await ValidateChildrenEmptyAsync(workspace, items[1]);
+            // |> CallS(c, [|CalculateDefault(c)|]) [Code.cs:22]
+            await ValidateChildrenEmptyAsync(workspace, items[3]);
+
+            // |> CallS(c, [|CalculateDefault(c)|]) [Code.cs:22]
+            var children = await ValidateChildrenAsync(
+                workspace,
+                items[2],
+                childInfo: new[]
+                {
+                    (37, "\"\""), // |>  return "" [Code.cs:37]
+                    (34, "\"defaultstring\""), // |>  return "defaultstring" [Code.cs:34]
+                    (29, "\"null\""), // |> return "null" [Code.cs:29]
+                });
+
+            foreach (var child in children)
+            {
+                await ValidateChildrenEmptyAsync(workspace, child);
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task MethodTracking2(TestHost testHost)
+        {
+            var code =
+@"
+class C
+{
+    public string S { get; set; } = """""";
+
+    public void SetS(string s)
+    {
+        S$$ = s;
+    }
+
+    public string GetS() => S;
+}
+
+class Other
+{
+    private readonly string _adornment;
+    public Other(string adornment)
+    {
+        _adornment = adornment;
+    }
+
+    public void CallS(C c, string s)
+    {
+        c.SetS(s);
+    }
+
+    public void CallS(C c)
+    {
+        CallS(c, CalculateDefault(c) + _adornment);
+    }
+
+    private string CalculateDefault(C c)
+    {
+        if (c is null)
+        {
+            return ""null"";
+        }
+
+        if (string.IsNullOrEmpty(c.S))
+        {
+            return ""defaultstring"";
+        }
+
+        return """";
+    }
+}
+
+class Program
+{
+    public static void Main(string[] args)
+    {
+        var other = new Other(""some value"");
+        var c = new C();
+        other.CallS(c);
+    }
+}
+";
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // S = s; [Code.cs:7]
+            //  |> S = [|s|] [Code.cs:7]
+            //    |> [|c.SetS(s)|]; [Code.cs:23]
+            //    |> c.SetS([|s|]); [Code.cs:23]
+            //      |> CallS([|c|], CalculateDefault(c) + _adornment) [Code.cs:28]
+            //        |> other.CallS([|c|]); [Code.cs:53]
+            //      |> CallS(c, CalculateDefault(c) + [|_adornment|]) [Code.cs:28]
+            //        |> _adornment = [|adornment|]; [Code.cs:18]
+            //          |> var other = new Other([|"some value"|]); [Code.cs:51]
+            //      |> CallS(c, CalculateDefault([|c|]) + _adornment) [Code.cs:28]
+            //        |> other.CallS([|c|]); [Code.cs:53]
+            //      |> CallS(c, [|CalculateDefault(c)|] + _adornment) [Code.cs:28]
+            //        |>  return "" [Code.cs:37]
+            //        |>  return "defaultstring" [Code.cs:34]
+            //        |> return "null" [Code.cs:29]
+            //      |> [|CallS(c, CalculateDefault(c) + _adornment)|] [Code.cs:28]
+            //
+            Assert.Equal(1, initialItems.Length);
+            ValidateItem(initialItems[0], 7);
+
+            var items = await ValidateChildrenAsync(
+                workspace,
+                initialItems.Single(),
+                childInfo: new[]
+                {
+                    (23, "s"), // |> c.SetS([|s|]); [Code.cs:23]
+                    (23, "c.SetS(s)"), // |> c.SetS(s); [Code.cs:23]
+                });
+
+            // |> c.SetS(s); [Code.cs:23]
+            await ValidateChildrenEmptyAsync(workspace, items[1]);
+
+            // |> c.SetS([|s|]); [Code.cs:23]
+            items = await ValidateChildrenAsync(
+                workspace,
+                items[0],
+                childInfo: new[]
+                {
+                    (28, "c" ), // |> CallS([|c|], CalculateDefault(c) + _adornment) [Code.cs:28]
+                    (28, "_adornment" ), // |> CallS(c, CalculateDefault(c) + [|_adornment|]) [Code.cs:28]
+                    (28, "c" ), // |> CallS(c, CalculateDefault([|c|]) + _adornment) [Code.cs:28]
+                    (28, "CalculateDefault(c)" ), // |> CallS(c, [|CalculateDefault|](c) + _adornment) [Code.cs:28]
+                    (28, "CallS(c, CalculateDefault(c) + _adornment)" ), // |> [|CallS(c, CalculateDefault(c) + _adornment)|] [Code.cs:28]
+                });
+
+            // |> CallS([|c|], CalculateDefault(c) + _adornment) [Code.cs:28]
+            var children = await ValidateChildrenAsync(
+                workspace,
+                items[0],
+                childInfo: new[]
+                {
+                    (53, "other.CallS(c)"), // |> other.CallS([|c|]); [Code.cs:53]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, children);
+
+            // |> CallS(c, CalculateDefault([|c|]) + _adornment) [Code.cs:28]
+            children = await ValidateChildrenAsync(
+                workspace,
+                items[2],
+                childInfo: new[]
+                {
+                    (53, "other.CallS(c)"), // |> other.CallS([|c|]); [Code.cs:53]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, children);
+
+            // |> CallS(c, CalculateDefault(c) + [|_adornment|]) [Code.cs:28]
+            children = await ValidateChildrenAsync(
+                workspace,
+                items[1],
+                childInfo: new[]
+                {
+                    (18, "adornment"), // |> _adornment = [|adornment|] [Code.cs:18]
+                });
+
+            children = await ValidateChildrenAsync(
+                workspace,
+                children.Single(),
+                childInfo: new[]
+                {
+                    (51, "\"some value\"") // |> var other = new Other([|"some value"|]); [Code.cs:51]
+                });
+            await ValidateChildrenEmptyAsync(workspace, children);
+
+            // |> CallS(c, [|CalculateDefault(c)|] + _adornment) [Code.cs:28]
+            children = await ValidateChildrenAsync(
+                workspace,
+                items[3],
+                childInfo: new[]
+                {
+                    (43, "\"\""), // |>  return "" [Code.cs:37]
+                    (40, "\"defaultstring\""), // |>  return "defaultstring" [Code.cs:34]
+                    (35, "\"null\""), // |> return "null" [Code.cs:29]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, children);
+
+            // |> [|CallS(c, CalculateDefault(c) + _adornment)|] [Code.cs:28]
+            await ValidateChildrenEmptyAsync(workspace, items[4]);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task MethodTracking3(TestHost testHost)
+        {
+            var code =
+@"
+using System.Threading.Tasks;
+
+namespace N
+{
+    class C
+    {
+        public int Add(int x, int y)
+        {
+            x += y;
+            return x;
+        }
+
+        public Task<int> AddAsync(int x, int y) => Task.FromResult(Add(x,y));
+
+        public async Task<int> Double(int x)
+        {
+            x = await AddAsync(x, x);
+            return $$x;
+        }
+    }
+}";
+            //
+            //  |> return [|x|] [Code.cs:18]
+            //    |> x = await AddAsync([|x|], x) [Code.cs:17]
+            //    |> x = await AddAsync(x, [|x|]) [Code.cs:17]
+            //    |> x = await [|AddAsync(x, x)|] [Code.cs:17]
+            //      |> [|Task.FromResult|](Add(x, y)) [Code.cs:13]
+            //      |> Task.FromResult([|Add(x, y)|]) [Code.cs:13]
+            //        |> return x [Code.cs:11]
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+            Assert.Equal(1, initialItems.Length);
+            ValidateItem(initialItems.Single(), 18, "x"); // |> return [|x|] [Code.cs:18]
+
+            var children = await ValidateChildrenAsync(
+                workspace,
+                initialItems.Single(),
+                childInfo: new[]
+                {
+                    (17, "x"), // |> x = await AddAsync([|x|], x) [Code.cs:17]
+                    (17, "x"), // |> x = await AddAsync(x, [|x|]) [Code.cs:17]
+                    (17, "AddAsync(x, x)") // |> x = await [|AddAsync(x, x)|] [Code.cs:17]
+                });
+
+            // |> x = await [|AddAsync(x, x)|] [Code.cs:17]
+            children = await ValidateChildrenAsync(
+                workspace,
+                children[2],
+                childInfo: new[]
+                {
+                    (13, "x"), // |> Task.FromResult(Add([|x|], y)) [Code.cs:13]
+                    (13, "y"), // |> Task.FromResult(Add(x, [|y|])) [Code.cs:13]
+                    (13, "Add(x,y)"),  // |> Task.FromResult([|Add(x, y)|]) [Code.cs:13]
+                    (13, "Task.FromResult(Add(x,y))"), // |> [|Task.FromResult|](Add(x, y)) [Code.cs:13]
+                });
+
+            // |> [|Task.FromResult|](Add(x, y)) [Code.cs:13]
+            await ValidateChildrenEmptyAsync(workspace, children[3]);
+
+            // |> Task.FromResult([|Add(x, y)|]) [Code.cs:13]
+            children = await ValidateChildrenAsync(
+                workspace,
+                children[2],
+                childInfo: new[]
+                {
+                    (10, "x") // |> return x [Code.cs:10]
+                });
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task OutParam(TestHost testHost)
+        {
+            var code = @"
+class C
+{
+    bool TryConvertInt(object o, out int i)
+    {
+        if (int.TryParse(o.ToString(), out i))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    void M()
+    {
+        int i = 0;
+        object o = ""5"";
+
+        if (TryConvertInt(o, out i))
+        {
+            Console.WriteLine($$i);
+        }
+        else
+        {
+            i = 2;
+        }
+    }
+}";
+
+            //
+            //  |> Console.WriteLine($$i); [Code.cs:20]
+            //    |> i = [|2|] [Code.cs:24]
+            //    |> if (TryConvertInt(o, out [|i|])) [Code.cs:18]
+            //      |> if (int.TryParse(o.ToString(), out [|i|])) [Code.cs:5]
+            //    |> int i = 0 [Code.cs:15]
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            Assert.Equal(1, initialItems.Length);
+
+            // |> Console.WriteLine($$i);[Code.cs:20]
+            ValidateItem(initialItems.Single(), 20, "i");
+
+            var children = await ValidateChildrenAsync(
+                workspace,
+                initialItems.Single(),
+                childInfo: new[]
+                {
+                    (24, "2"), // |> i = [|2|] [Code.cs:24]
+                    (18, "i"), // |> if (TryConvertInt(o, out [|i|])) [Code.cs:18]
+                    (15, "0"), // |> int i = 0 [Code.cs:15]
+                });
+
+            // |> i = [|2|] [Code.cs:24]
+            await ValidateChildrenEmptyAsync(workspace, children[0]);
+
+            // |> if (TryConvertInt(o, out [|i|])) [Code.cs:18]
+            children = await ValidateChildrenAsync(
+                workspace,
+                children[1],
+                childInfo: new[]
+                {
+                    (5, "i") // |> if (int.TryParse(o.ToString(), out [|i|])) [Code.cs:5]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, children.Single());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestVariableReferenceStart(TestHost testHost)
+        {
+            var code =
+@"
+class Test
+{
+    public static void M()
+    {
+        int x = GetM();
+        Console.Write(x);
+        var y = $$x + 1;
+    }
+
+    public static int GetM()
+    {
+        var x = 0;
+        return x;
+    }
+}";
+
+            //
+            //  |> var y = x + 1; [Code.cs:7]
+            //    |> int x = GetM() [Code.cs:5]
+            //      |> return x; [Code.cs:13]
+            //        |> var x = 0; [Code.cs:12]
+            using var workspace = CreateWorkspace(code, testHost);
+
+            var items = await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (7, "x") // |> var y = [|x|] + 1; [Code.cs:7]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (5, "GetM()") // |> int x = [|GetM()|] [Code.cs:5]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (13, "x") // |> return [|x|]; [Code.cs:13]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (12, "0") // |> var x = [|0|]; [Code.cs:12]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, items.Single());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestVariableReferenceStart2(TestHost testHost)
+        {
+            var code =
+@"
+class Test
+{
+    public static void M()
+    {
+        int x = GetM();
+        Console.Write($$x);
+        var y = x + 1;
+    }
+
+    public static int GetM()
+    {
+        var x = 0;
+        return x;
+    }
+}";
+
+            //
+            //  |> Console.Write(x); [Code.cs:6]
+            //    |> int x = GetM() [Code.cs:5]
+            //      |> return x; [Code.cs:13]
+            //        |> var x = 0; [Code.cs:12]
+            using var workspace = CreateWorkspace(code, testHost);
+
+            var items = await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (6, "x") // |> Console.Write([|x|]); [Code.cs:7]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (5, "GetM()") // |> int x = [|GetM()|] [Code.cs:5]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (13, "x") // |> return [|x|]; [Code.cs:13]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (12, "0") // |> var x = [|0|]; [Code.cs:12]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, items.Single());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestVariableReferenceStart3(TestHost testHost)
+        {
+            var code =
+@"
+class Test
+{
+    public static void M()
+    {
+        int x = GetM();
+        Console.Write($$x);
+        var y = x + 1;
+        x += 1;
+        Console.Write(x);
+        Console.Write(y);
+    }
+
+    public static int GetM()
+    {
+        var x = 0;
+        return x;
+    }
+}";
+
+            //
+            //  |> Console.Write(x); [Code.cs:6]
+            //    |> int x = GetM() [Code.cs:5]
+            //      |> return x; [Code.cs:13]
+            //        |> var x = 0; [Code.cs:12]
+            //    |> x += 1 [Code.cs:8]
+            using var workspace = CreateWorkspace(code, testHost);
+
+            var items = await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (6, "x") // |> Console.Write([|x|]); [Code.cs:7]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (8, "1"),      // |> x += 1; [Codec.s:8]
+                    (5, "GetM()"), // |> int x = [|GetM()|] [Code.cs:5]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, items[0]);
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items[1],
+                childInfo: new[]
+                {
+                    (16, "x") // |> return [|x|]; [Code.cs:13]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (15, "0") // |> var x = [|0|]; [Code.cs:12]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, items.Single());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestMultipleDeclarators(TestHost testHost)
+        {
+            var code =
+@"
+class Test
+{
+    public static void M()
+    {
+        int x = GetM(), z = 5;
+        Console.Write($$x);
+        var y = x + 1 + z;
+        x += 1;
+        Console.Write(x);
+        Console.Write(y);
+    }
+
+    public static int GetM()
+    {
+        var x = 0;
+        return x;
+    }
+}";
+
+            //
+            //  |> Console.Write(x); [Code.cs:6]
+            //    |> int x = GetM() [Code.cs:5]
+            //      |> return x; [Code.cs:13]
+            //        |> var x = 0; [Code.cs:12]
+            //    |> x += 1 [Code.cs:8]
+            using var workspace = CreateWorkspace(code, testHost);
+
+            var items = await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (6, "x") // |> Console.Write([|x|]); [Code.cs:7]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (8, "1"),      // |> x += 1; [Codec.s:8]
+                    (5, "GetM()"), // |> int x = [|GetM()|] [Code.cs:5]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, items[0]);
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items[1],
+                childInfo: new[]
+                {
+                    (16, "x") // |> return [|x|]; [Code.cs:13]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (15, "0") // |> var x = [|0|]; [Code.cs:12]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, items.Single());
+        }
+    }
+}
diff --git a/src/EditorFeatures/Test/ValueTracking/VisualBasicValueTrackingTests.cs b/src/EditorFeatures/Test/ValueTracking/VisualBasicValueTrackingTests.cs
new file mode 100644
index 0000000000000..96cd454d6ffb0
--- /dev/null
+++ b/src/EditorFeatures/Test/ValueTracking/VisualBasicValueTrackingTests.cs
@@ -0,0 +1,334 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Remote.Testing;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests.ValueTracking
+{
+    [UseExportProvider]
+    public class VisualBasicValueTrackingTests : AbstractBaseValueTrackingTests
+    {
+        protected override TestWorkspace CreateWorkspace(string code, TestComposition composition)
+            => TestWorkspace.CreateVisualBasic(code, composition: composition);
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestProperty(TestHost testHost)
+        {
+            var code =
+@"
+Class C
+    Private _s As String
+    Public Property $$S() As String
+        Get
+            Return _s
+        End Get
+        Set(ByVal value As String)
+            _s = value
+        End Set
+    End Property
+
+    
+    Public Sub SetS(s As String)
+        Me.S = s
+    End Sub
+
+    Public Function GetS() As String
+        Return Me.S
+    End Function
+End Class
+";
+
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // property S 
+            //  |> Me.S = s [Code.vb:14]
+            //  |> Public Property S() As String [Code.vb:3]
+            //
+            Assert.Equal(2, initialItems.Length);
+            ValidateItem(initialItems[0], 14);
+            ValidateItem(initialItems[1], 3);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestField(TestHost testHost)
+        {
+            var code =
+@"
+Class C
+    Private $$_s As String = """"
+    
+    Public Sub SetS(s As String)
+        Me._s = s
+    End Sub
+
+    Public Function GetS() As String
+        Return Me._s
+    End Function
+End Class
+";
+
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // field _s 
+            //  |> Me._s = s [Code.vb:4]
+            //  |> Private _s As String = "" [Code.vb:2]
+            //
+            await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (5, "s"),
+                    (2, "_s")
+                });
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestLocal(TestHost testHost)
+        {
+            var code =
+@"
+Class C    
+    Public Function Add(x As Integer, y As Integer) As Integer
+        Dim $$z = x
+        z += y
+        Return z
+    End Function
+End Class
+";
+
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // local variable z 
+            //  |> z += y [Code.vb:4]
+            //  |> Dim z = x [Code.vb:3]
+            //
+            Assert.Equal(2, initialItems.Length);
+            ValidateItem(initialItems[0], 4);
+            ValidateItem(initialItems[1], 3);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestParameter(TestHost testHost)
+        {
+            var code =
+@"
+Class C    
+    Public Function Add($$x As Integer, y As Integer) As Integer
+        x += y
+        Return x
+    End Function
+End Class
+";
+
+            using var workspace = CreateWorkspace(code, testHost);
+            var initialItems = await GetTrackedItemsAsync(workspace);
+
+            //
+            // parameter x
+            //  |> x += y [Code.vb:3]
+            //  |> Public Function Add(x As integer, y As Integer) As Integer [Code.vb:2]
+            //
+            Assert.Equal(2, initialItems.Length);
+            ValidateItem(initialItems[0], 3);
+            ValidateItem(initialItems[1], 2);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestVariableReferenceStart(TestHost testHost)
+        {
+            var code =
+@"
+Class Test
+    Public Sub M()
+        Dim x = GetM()
+        Console.Write(x)
+        Dim y = $$x + 1
+    End Sub
+
+    Public Function GetM() As Integer
+        Dim x = 0
+        Return x
+    End Function
+End Class";
+
+            //
+            //  |> Dim y = x + 1 [Code.vb:7]
+            //    |> Dim x = GetM() [Code.vb:5]
+            //      |> Return x; [Code.vb:13]
+            //        |> Dim x = 0; [Code.vb:12]
+            using var workspace = CreateWorkspace(code, testHost);
+
+            var items = await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (5, "x") // |> Dim y = [|x|] + 1; [Code.vb:7]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (3, "GetM()") // |> Dim x = [|GetM()|] [Code.vb:5]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (10, "x") // |> return [|x|]; [Code.vb:13]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (9, "0") // |> var x = [|0|]; [Code.vb:12]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, items.Single());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestVariableReferenceStart2(TestHost testHost)
+        {
+            var code =
+@"
+Class Test
+    Public Sub M()
+        Dim x = GetM()
+        Console.Write($$x)
+        Dim y = x + 1
+    End Sub
+
+    Public Function GetM() As Integer
+        Dim x = 0
+        Return x
+    End Function
+End Class";
+
+            //
+            //  |> Dim y = x + 1 [Code.vb:7]
+            //    |> Dim x = GetM() [Code.vb:5]
+            //      |> Return x; [Code.vb:13]
+            //        |> Dim x = 0; [Code.vb:12]
+            using var workspace = CreateWorkspace(code, testHost);
+
+            var items = await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (4, "x") // |> Dim y = [|x|] + 1; [Code.vb:7]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (3, "GetM()") // |> Dim x = [|GetM()|] [Code.vb:5]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (10, "x") // |> return [|x|]; [Code.vb:13]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (9, "0") // |> var x = [|0|]; [Code.vb:12]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, items.Single());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestMultipleDeclarators(TestHost testHost)
+        {
+            var code =
+@"
+Imports System
+
+Class Test
+    Public Sub M()
+        Dim x = GetM(), z = 1, m As Boolean, n As Boolean, o As Boolean
+        Console.Write(x)
+        Dim y = $$x + 1
+    End Sub
+
+    Public Function GetM() As Integer
+        Dim x = 0
+        Return x
+    End Function
+End Class";
+
+            //
+            //  |> Dim y = x + 1 [Code.vb:7]
+            //    |> Dim x = GetM(), z = 1, m As Boolean, n As Boolean, o As Boolean [Code.vb:5]
+            //      |> Return x; [Code.vb:12]
+            //        |> Dim x = 0; [Code.vb:11]
+            using var workspace = CreateWorkspace(code, testHost);
+
+            var items = await ValidateItemsAsync(
+                workspace,
+                itemInfo: new[]
+                {
+                    (7, "x") // |> Dim y = [|x|] + 1; [Code.vb:7]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (5, "GetM()") // |> Dim x = [|GetM()|], z = 1, m As Boolean, n As Boolean, o As Boolean [Code.vb:5]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (12, "x") // |> return [|x|]; [Code.vb:12]
+                });
+
+            items = await ValidateChildrenAsync(
+                workspace,
+                items.Single(),
+                childInfo: new[]
+                {
+                    (11, "0") // |> var x = [|0|]; [Code.vb:11]
+                });
+
+            await ValidateChildrenEmptyAsync(workspace, items.Single());
+        }
+    }
+}
diff --git a/src/EditorFeatures/Test/Workspaces/ProjectCacheHostServiceFactoryTests.cs b/src/EditorFeatures/Test/Workspaces/ProjectCacheHostServiceFactoryTests.cs
index a01bff35edaa1..1f55e9d7d2332 100644
--- a/src/EditorFeatures/Test/Workspaces/ProjectCacheHostServiceFactoryTests.cs
+++ b/src/EditorFeatures/Test/Workspaces/ProjectCacheHostServiceFactoryTests.cs
@@ -30,7 +30,7 @@ private static void Test(Action<IProjectCacheHostService, ProjectId, ICachedObje
             // Putting cacheService.CreateStrongReference in a using statement
             // creates a temporary local that isn't collected in Debug builds
             // Wrapping it in a lambda allows it to get collected.
-            var cacheService = new ProjectCacheService(null, int.MaxValue);
+            var cacheService = new ProjectCacheService(null, TimeSpan.MaxValue);
             var projectId = ProjectId.CreateNewId();
             var owner = new Owner();
             var instance = ObjectReference.CreateFromFactory(() => new object());
@@ -113,7 +113,7 @@ public void TestCacheDoesNotKeepObjectsAliveAfterOwnerIsCollected2()
         public void TestImplicitCacheKeepsObjectAlive1()
         {
             var workspace = new AdhocWorkspace(MockHostServices.Instance, workspaceKind: WorkspaceKind.Host);
-            var cacheService = new ProjectCacheService(workspace, int.MaxValue);
+            var cacheService = new ProjectCacheService(workspace, TimeSpan.MaxValue);
             var reference = ObjectReference.CreateFromFactory(() => new object());
             reference.UseReference(r => cacheService.CacheObjectIfCachingEnabledForKey(ProjectId.CreateNewId(), (object)null, r));
             reference.AssertHeld();
@@ -125,7 +125,7 @@ public void TestImplicitCacheKeepsObjectAlive1()
         public void TestImplicitCacheMonitoring()
         {
             var workspace = new AdhocWorkspace(MockHostServices.Instance, workspaceKind: WorkspaceKind.Host);
-            var cacheService = new ProjectCacheService(workspace, 10);
+            var cacheService = new ProjectCacheService(workspace, TimeSpan.FromMilliseconds(10));
             var weak = PutObjectInImplicitCache(cacheService);
 
             weak.AssertReleased();
@@ -156,7 +156,7 @@ public void TestP2PReference()
 
             var instanceTracker = ObjectReference.CreateFromFactory(() => new object());
 
-            var cacheService = new ProjectCacheService(workspace, int.MaxValue);
+            var cacheService = new ProjectCacheService(workspace, TimeSpan.MaxValue);
             using (var cache = cacheService.EnableCaching(project2.Id))
             {
                 instanceTracker.UseReference(r => cacheService.CacheObjectIfCachingEnabledForKey(project1.Id, (object)null, r));
@@ -184,7 +184,7 @@ public void TestEjectFromImplicitCache()
             var weakLast = ObjectReference.Create(compilations[compilations.Count - 1]);
 
             var workspace = new AdhocWorkspace(MockHostServices.Instance, workspaceKind: WorkspaceKind.Host);
-            var cache = new ProjectCacheService(workspace, int.MaxValue);
+            var cache = new ProjectCacheService(workspace, TimeSpan.MaxValue);
             for (var i = 0; i < ProjectCacheService.ImplicitCacheSize + 1; i++)
             {
                 cache.CacheObjectIfCachingEnabledForKey(ProjectId.CreateNewId(), (object)null, compilations[i]);
@@ -212,7 +212,7 @@ public void TestCacheCompilationTwice()
             var weak1 = ObjectReference.Create(comp1);
 
             var workspace = new AdhocWorkspace(MockHostServices.Instance, workspaceKind: WorkspaceKind.Host);
-            var cache = new ProjectCacheService(workspace, int.MaxValue);
+            var cache = new ProjectCacheService(workspace, TimeSpan.MaxValue);
             var key = ProjectId.CreateNewId();
             var owner = new object();
             cache.CacheObjectIfCachingEnabledForKey(key, owner, comp1);
diff --git a/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb b/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb
index 6e1d67f374f09..34eae7c6195c6 100644
--- a/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/DiagnosticProviderTests.vb
@@ -357,6 +357,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests
                     result.Add(SourceWarning(Id, message, documentId, documentId.ProjectId, mappedLine, originalLine, mappedColumn, originalColumn, mappedFile, originalFile))
                 End If
             Next
+
             Return result
         End Function
 
diff --git a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb
index a914934f45228..3bc784a48bacd 100644
--- a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb
@@ -1648,6 +1648,7 @@ public class B
                                                                                                      If (symbols.Contains(sc.Symbol)) Then
                                                                                                          Throw New Exception("Duplicate symbol callback")
                                                                                                      End If
+
                                                                                                      sc.ReportDiagnostic(Diagnostic.Create(DiagDescriptor, sc.Symbol.Locations.First()))
                                                                                                  End Sub, SymbolKind.NamedType)
                                                        End Sub)
diff --git a/src/EditorFeatures/Test2/Expansion/AbstractExpansionTest.vb b/src/EditorFeatures/Test2/Expansion/AbstractExpansionTest.vb
index b9b2ff8c90a3b..f2ddb6aadf2ff 100644
--- a/src/EditorFeatures/Test2/Expansion/AbstractExpansionTest.vb
+++ b/src/EditorFeatures/Test2/Expansion/AbstractExpansionTest.vb
@@ -57,6 +57,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Expansion
                     Exit While
                 End If
             End While
+
             Return node
         End Function
 
diff --git a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.EventSymbols.vb b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.EventSymbols.vb
index 00372e514edbd..520dbba6235ca 100644
--- a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.EventSymbols.vb
+++ b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.EventSymbols.vb
@@ -316,5 +316,150 @@ End Interface
 </Workspace>
             Await TestAPIAndFeature(input, kind, host)
         End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestStaticAbstractEventInInterface(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" AssemblyName="CSharpAssembly" CommonReferences="true">
+        <Document>
+interface I3
+{
+    abstract static event System.Action {|Definition:E$$3|};
+}
+
+class C3_1 : I3
+{
+    public static event System.Action {|Definition:E3|};
+}
+
+class C3_2 : I3
+{
+    static event System.Action I3.{|Definition:E3|}
+    {
+        add { }
+        remove { }
+    }
+}        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestStaticAbstractEventViaFeature1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" AssemblyName="CSharpAssembly" CommonReferences="true">
+        <Document>
+interface I3
+{
+    abstract static event System.Action {|Definition:E3|};
+}
+
+class C3_1 : I3
+{
+    public static event System.Action {|Definition:E$$3|};
+}
+
+class C3_2 : I3
+{
+    static event System.Action I3.E3
+    {
+        add { }
+        remove { }
+    }
+}        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestStaticAbstractEventViaFeature2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" AssemblyName="CSharpAssembly" CommonReferences="true">
+        <Document>
+interface I3
+{
+    abstract static event System.Action {|Definition:E3|};
+}
+
+class C3_1 : I3
+{
+    public static event System.Action E3;
+}
+
+class C3_2 : I3
+{
+    static event System.Action I3.{|Definition:E$$3|}
+    {
+        add { }
+        remove { }
+    }
+}        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestStaticAbstractEventViaAPI1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" AssemblyName="CSharpAssembly" CommonReferences="true">
+        <Document>
+interface I3
+{
+    abstract static event System.Action {|Definition:E3|};
+}
+
+class C3_1 : I3
+{
+    public static event System.Action {|Definition:E3|};
+}
+
+class C3_2 : I3
+{
+    static event System.Action I3.{|Definition:E$$3|}
+    {
+        add { }
+        remove { }
+    }
+}        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestStaticAbstractEventViaAPI2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" AssemblyName="CSharpAssembly" CommonReferences="true">
+        <Document>
+interface I3
+{
+    abstract static event System.Action {|Definition:E3|};
+}
+
+class C3_1 : I3
+{
+    public static event System.Action {|Definition:E$$3|};
+}
+
+class C3_2 : I3
+{
+    static event System.Action I3.{|Definition:E3|}
+    {
+        add { }
+        remove { }
+    }
+}        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
     End Class
 End Namespace
diff --git a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.OperatorSymbols.vb b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.OperatorSymbols.vb
index dabf62fca6418..847bd34707da8 100644
--- a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.OperatorSymbols.vb
+++ b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.OperatorSymbols.vb
@@ -483,5 +483,274 @@ class B
             Await TestAPIAndFeature(input, kind, host)
         End Function
 
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractConversionOperatorInInterface(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I5<T> where T : I5<T>
+{
+    abstract static implicit operator {|Definition:i$$nt|}(T x);
+}
+
+class C5_1 : I5<C5_1>
+{
+    public static implicit operator {|Definition:int|}(C5_1 x) => default;
+}
+
+class C5_2 : I5<C5_2>
+{
+    static implicit I5<C5_2>.operator {|Definition:int|}(C5_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractConversionOperatorViaFeature1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I5<T> where T : I5<T>
+{
+    abstract static implicit operator {|Definition:int|}(T x);
+}
+
+class C5_1 : I5<C5_1>
+{
+    public static implicit operator {|Definition:i$$nt|}(C5_1 x) => default;
+}
+
+class C5_2 : I5<C5_2>
+{
+    static implicit I5<C5_2>.operator int(C5_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractConversionOperatorViaFeature2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I5<T> where T : I5<T>
+{
+    abstract static implicit operator {|Definition:int|}(T x);
+}
+
+class C5_1 : I5<C5_1>
+{
+    public static implicit operator int(C5_1 x) => default;
+}
+
+class C5_2 : I5<C5_2>
+{
+    static implicit I5<C5_2>.operator {|Definition:i$$nt|}(C5_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractConversionOperatorViaApi1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I5<T> where T : I5<T>
+{
+    abstract static implicit operator {|Definition:int|}(T x);
+}
+
+class C5_1 : I5<C5_1>
+{
+    public static implicit operator {|Definition:int|}(C5_1 x) => default;
+}
+
+class C5_2 : I5<C5_2>
+{
+    static implicit I5<C5_2>.operator {|Definition:i$$nt|}(C5_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractConversionOperatorViaApi2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I5<T> where T : I5<T>
+{
+    abstract static implicit operator {|Definition:int|}(T x);
+}
+
+class C5_1 : I5<C5_1>
+{
+    public static implicit operator {|Definition:in$$t|}(C5_1 x) => default;
+}
+
+class C5_2 : I5<C5_2>
+{
+    static implicit I5<C5_2>.operator {|Definition:int|}(C5_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractOperatorInInterface(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I4<T> where T : I4<T>
+{
+    abstract static int operator {|Definition:+$$|}(T x);
+}
+
+class C4_1 : I4<C4_1>
+{
+    public static int operator {|Definition:+|}(C4_1 x) => default;
+}
+
+class C4_2 : I4<C4_2>
+{
+    static int I4<C4_2>.operator {|Definition:+|}(C4_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractOperatorViaApi1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I4<T> where T : I4<T>
+{
+    abstract static int operator {|Definition:+|}(T x);
+}
+
+class C4_1 : I4<C4_1>
+{
+    public static int operator {|Definition:$$+|}(C4_1 x) => default;
+}
+
+class C4_2 : I4<C4_2>
+{
+    static int I4<C4_2>.operator {|Definition:+|}(C4_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractOperatorViaApi2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I4<T> where T : I4<T>
+{
+    abstract static int operator {|Definition:+|}(T x);
+}
+
+class C4_1 : I4<C4_1>
+{
+    public static int operator {|Definition:+|}(C4_1 x) => default;
+}
+
+class C4_2 : I4<C4_2>
+{
+    static int I4<C4_2>.operator {|Definition:$$+|}(C4_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractOperatorViaFeature1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I4<T> where T : I4<T>
+{
+    abstract static int operator {|Definition:+|}(T x);
+}
+
+class C4_1 : I4<C4_1>
+{
+    public static int operator {|Definition:$$+|}(C4_1 x) => default;
+}
+
+class C4_2 : I4<C4_2>
+{
+    static int I4<C4_2>.operator +(C4_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharpStaticAbstractOperatorViaFeature2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+            <![CDATA[
+interface I4<T> where T : I4<T>
+{
+    abstract static int operator {|Definition:+|}(T x);
+}
+
+class C4_1 : I4<C4_1>
+{
+    public static int operator +(C4_1 x) => default;
+}
+
+class C4_2 : I4<C4_2>
+{
+    static int I4<C4_2>.operator {|Definition:$$+|}(C4_2 x) => default;
+}]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
     End Class
 End Namespace
diff --git a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.OrdinaryMethodSymbols.vb b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.OrdinaryMethodSymbols.vb
index 159df9d86c166..b56ee8a7847a3 100644
--- a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.OrdinaryMethodSymbols.vb
+++ b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.OrdinaryMethodSymbols.vb
@@ -3786,5 +3786,125 @@ End Class
 </Workspace>
             Await TestStreamingFeature(input, host)
         End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestMemberStaticAbstractMethodFromInterface(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+        interface I1
+        {
+            static abstract void {|Definition:M$$1|}();
+        }
+        class C1_1 : I1
+        {
+            public static void {|Definition:M1|}() { }
+        }
+        class C1_2 : I1
+        {
+            static void I1.{|Definition:M1|}() { }
+        }
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestDerivedMemberStaticAbstractMethodViaFeature1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+        interface I1
+        {
+            static abstract void {|Definition:M1|}();
+        }
+        class C1_1 : I1
+        {
+            public static void {|Definition:M$$1|}() { }
+        }
+        class C1_2 : I1
+        {
+            static void I1.M1() { }
+        }
+        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestDerivedMemberStaticAbstractMethodViaFeature2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+        interface I1
+        {
+            static abstract void {|Definition:M1|}();
+        }
+        class C1_1 : I1
+        {
+            public static void M1() { }
+        }
+        class C1_2 : I1
+        {
+            static void I1.{|Definition:M$$1|}() { }
+        }
+        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestDerivedMemberStaticAbstractMethodViaAPI1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+        interface I1
+        {
+            static abstract void {|Definition:M1|}();
+        }
+        class C1_1 : I1
+        {
+            public static void {|Definition:M$$1|}() { }
+        }
+        class C1_2 : I1
+        {
+            static void I1.{|Definition:M1|}() { }
+        }
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestDerivedMemberStaticAbstractMethodViaAPI2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+        interface I1
+        {
+            static abstract void {|Definition:M1|}();
+        }
+        class C1_1 : I1
+        {
+            public static void {|Definition:M1|}() { }
+        }
+        class C1_2 : I1
+        {
+            static void I1.{|Definition:M$$1|}() { }
+        }
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
     End Class
 End Namespace
diff --git a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.PropertySymbols.vb b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.PropertySymbols.vb
index 68ce3668624f5..9faa9028e087d 100644
--- a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.PropertySymbols.vb
+++ b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.PropertySymbols.vb
@@ -1084,5 +1084,135 @@ namespace ConsoleApplication22
 </Workspace>
             Await TestAPIAndFeature(input, kind, host)
         End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharp_AbstractStaticPropertyInInterface(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+interface I2
+{
+    abstract static int {|Definition:P$$2|} { get; set; }
+}
+
+class C2_1 : I2
+{
+    public static int {|Definition:P2|} { get; set; }
+}
+
+class C2_2 : I2
+{
+    static int I2.{|Definition:P2|} { get; set; }
+}
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharp_AbstractStaticPropertyViaFeature1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+interface I2
+{
+    abstract static int {|Definition:P2|} { get; set; }
+}
+
+class C2_1 : I2
+{
+    public static int {|Definition:P$$2|} { get; set; }
+}
+
+class C2_2 : I2
+{
+    static int I2.P2 { get; set; }
+}
+        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharp_AbstractStaticPropertyViaFeature2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+interface I2
+{
+    abstract static int {|Definition:P2|} { get; set; }
+}
+
+class C2_1 : I2
+{
+    public static int P2 { get; set; }
+}
+
+class C2_2 : I2
+{
+    static int I2.{|Definition:P$$2|} { get; set; }
+}
+        </Document>
+    </Project>
+</Workspace>
+            Await TestStreamingFeature(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharp_AbstractStaticPropertyViaAPI1(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+interface I2
+{
+    abstract static int {|Definition:P2|} { get; set; }
+}
+
+class C2_1 : I2
+{
+    public static int {|Definition:P2|} { get; set; }
+}
+
+class C2_2 : I2
+{
+    static int I2.{|Definition:P$$2|} { get; set; }
+}
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestCSharp_AbstractStaticPropertyViaAPI2(host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+interface I2
+{
+    abstract static int {|Definition:P2|} { get; set; }
+}
+
+class C2_1 : I2
+{
+    public static int {|Definition:P$$2|} { get; set; }
+}
+
+class C2_2 : I2
+{
+    static int I2.{|Definition:P2|} { get; set; }
+}
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPI(input, host)
+        End Function
     End Class
 End Namespace
diff --git a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.vb b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.vb
index a8cc26e9efcf4..e88e0ee842ffd 100644
--- a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.vb
+++ b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.vb
@@ -169,6 +169,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.FindReferences
                     propertyValues = New HashSet(Of String)()
                     additionalPropertiesMap.Add(propertyName, propertyValues)
                 End If
+
                 propertyValues.Add(propertyValue)
             Next
 
@@ -438,6 +439,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.FindReferences
                 builder.Append(suffix)
                 position = span.End
             Next
+
             builder.Append(text.GetSubText(New TextSpan(position, text.Length - position)))
 
             Return instance.ToStringAndFree()
diff --git a/src/EditorFeatures/Test2/GoToDefinition/CSharpGoToDefinitionTests.vb b/src/EditorFeatures/Test2/GoToDefinition/CSharpGoToDefinitionTests.vb
index 66602cf6999fb..f5e8c6909494c 100644
--- a/src/EditorFeatures/Test2/GoToDefinition/CSharpGoToDefinitionTests.vb
+++ b/src/EditorFeatures/Test2/GoToDefinition/CSharpGoToDefinitionTests.vb
@@ -1777,6 +1777,7 @@ namespace QueryPattern
             If highlight = "" Then
                 Return definition
             End If
+
             Dim searchStartPosition As Integer = 0
             Dim searchFound As Integer
             For i As Integer = 0 To index
@@ -1785,11 +1786,13 @@ namespace QueryPattern
                     Exit For
                 End If
             Next
+
             If searchFound >= 0 Then
                 definition = definition.Insert(searchFound + highlight.Length, "|]")
                 definition = definition.Insert(searchFound, "[|")
                 Return definition
             End If
+
             Throw New InvalidOperationException("Highlight not found")
         End Function
 
diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
index a75a77c6f2ee1..b9fe83b42bd23 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
@@ -482,6 +482,7 @@ record Derived(int Other) : [|Base$$|]
                 If showCompletionInArgumentLists Then
                     Await state.AssertSelectedCompletionItem(displayText:="Alice:", isHardSelected:=True)
                 End If
+
                 state.SendTypeChars(": 1, B")
 
                 If showCompletionInArgumentLists Then
@@ -800,6 +801,7 @@ class C
                     state.SendBackspace()
                     Await state.WaitForAsynchronousOperationsAsync()
                 Next
+
                 Await state.AssertCompletionSession()
 
                 state.SendBackspace()
@@ -2335,6 +2337,7 @@ public class C
                 Else
                     Await state.AssertNoCompletionSession()
                 End If
+
                 state.SendTypeChars("A")
                 Await state.AssertSelectedCompletionItem(displayText:="Alice:", isHardSelected:=True)
                 state.SendTypeChars(":")
@@ -4887,6 +4890,7 @@ class C
                 For i = 1 To "ConfigureAwait".Length
                     state.SendBackspace()
                 Next
+
                 state.SendInvokeCompletionList()
                 Await state.AssertCompletionSession()
                 Await state.AssertSelectedCompletionItem("ConfigureAwait")
@@ -5156,6 +5160,7 @@ class C
                 For i As Integer = 1 To "System.".Length
                     state.SendBackspace()
                 Next
+
                 state.SendEscape()
 
                 Await state.WaitForAsynchronousOperationsAsync()
@@ -5177,6 +5182,7 @@ class C
                 For i As Integer = 1 To "Sys.".Length
                     state.SendBackspace()
                 Next
+
                 state.SendEscape()
 
                 Await state.WaitForAsynchronousOperationsAsync()
@@ -6565,12 +6571,14 @@ class C
                 For i = 1 To "ze".Length
                     state.SendBackspace()
                 Next
+
                 Await state.AssertSelectedCompletionItem("★ Normalize", displayTextSuffix:="()")
 
                 state.SendEscape()
                 For i = 1 To "Normali".Length
                     state.SendBackspace()
                 Next
+
                 state.SendEscape()
                 Assert.Contains("s.", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
 
@@ -6619,12 +6627,14 @@ class C
                 For i = 1 To "ze".Length
                     state.SendBackspace()
                 Next
+
                 Await state.AssertSelectedCompletionItem("★ Normalize", displayTextSuffix:="()")
 
                 state.SendEscape()
                 For i = 1 To "Normali".Length
                     state.SendBackspace()
                 Next
+
                 state.SendEscape()
                 Assert.Contains("s.", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
 
diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_InternalsVisibleTo.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_InternalsVisibleTo.vb
index 125627f1a80fe..345363dd95215 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_InternalsVisibleTo.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_InternalsVisibleTo.vb
@@ -165,6 +165,7 @@ namespace A
                         state.SendInvokeCompletionList()
                         Await state.AssertSessionIsNothingOrNoCompletionItemLike("ClassLibrary1")
                     End Function
+
                 Await AssertNoCompletionAndCompletionDoesNotContainClassLibrary1()
                 state.SendTypeChars("["c)
 
diff --git a/src/EditorFeatures/Test2/IntelliSense/IntellisenseQuickInfoBuilderTests_Code.vb b/src/EditorFeatures/Test2/IntelliSense/IntellisenseQuickInfoBuilderTests_Code.vb
new file mode 100644
index 0000000000000..25d531e754130
--- /dev/null
+++ b/src/EditorFeatures/Test2/IntelliSense/IntellisenseQuickInfoBuilderTests_Code.vb
@@ -0,0 +1,113 @@
+' Licensed to the .NET Foundation under one or more agreements.
+' The .NET Foundation licenses this file to you under the MIT license.
+' See the LICENSE file in the project root for more information.
+
+Imports Microsoft.CodeAnalysis.Classification
+Imports Microsoft.CodeAnalysis.Test.Utilities.QuickInfo
+Imports Microsoft.VisualStudio.Core.Imaging
+Imports Microsoft.VisualStudio.Imaging
+Imports Microsoft.VisualStudio.Text.Adornments
+
+Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
+    Public Class IntellisenseQuickInfoBuilderTests_Code
+        Inherits AbstractIntellisenseQuickInfoBuilderTests
+        <WpfFact, Trait(Traits.Feature, Traits.Features.QuickInfo)>
+        Public Async Function QuickInfoForXmlCodeElementWithCDATA() As Task
+            Dim workspace =
+                <Workspace>
+                    <Project Language="C#" CommonReferences="true">
+                        <Document>
+                            class MyClass {
+                                /// &lt;summary&gt;
+                                /// summary for MyClass
+                                /// &lt;code&gt;&lt;![CDATA[
+                                /// List&lt;string&gt; y = null;
+                                /// ]]&gt;&lt;/code&gt;
+                                /// &lt;/summary&gt;
+                                void MyMethod() {
+                                    MyM$$ethod();
+                                }
+                            }
+                        </Document>
+                    </Project>
+                </Workspace>
+
+            Dim intellisenseQuickInfo = Await GetQuickInfoItemAsync(workspace, LanguageNames.CSharp)
+
+            Dim expected = New ContainerElement(
+                ContainerElementStyle.Stacked Or ContainerElementStyle.VerticalPadding,
+                New ContainerElement(
+                    ContainerElementStyle.Stacked,
+                    New ContainerElement(
+                        ContainerElementStyle.Wrapped,
+                        New ImageElement(New ImageId(KnownImageIds.ImageCatalogGuid, KnownImageIds.MethodPrivate)),
+                        New ClassifiedTextElement(
+                            New ClassifiedTextRun(ClassificationTypeNames.Keyword, "void"),
+                            New ClassifiedTextRun(ClassificationTypeNames.WhiteSpace, " "),
+                            New ClassifiedTextRun(ClassificationTypeNames.ClassName, "MyClass", navigationAction:=Sub() Return, "MyClass"),
+                            New ClassifiedTextRun(ClassificationTypeNames.Punctuation, "."),
+                            New ClassifiedTextRun(ClassificationTypeNames.MethodName, "MyMethod", navigationAction:=Sub() Return, "void MyClass.MyMethod()"),
+                            New ClassifiedTextRun(ClassificationTypeNames.Punctuation, "("),
+                            New ClassifiedTextRun(ClassificationTypeNames.Punctuation, ")"))),
+                    New ClassifiedTextElement(
+                        New ClassifiedTextRun(ClassificationTypeNames.Text, "summary for MyClass"))),
+                New ClassifiedTextElement(
+                    New ClassifiedTextRun(ClassificationTypeNames.Text, "List<string> y = null;", ClassifiedTextRunStyle.UseClassificationFont)))
+
+            ToolTipAssert.EqualContent(expected, intellisenseQuickInfo.Item)
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.QuickInfo)>
+        Public Async Function QuickInfoForXmlCodeElement() As Task
+            Dim workspace =
+                <Workspace>
+                    <Project Language="C#" CommonReferences="true">
+                        <Document>
+                            class MyClass {
+                                /// &lt;summary&gt;
+                                /// Normalize    this, &lt;c&gt;and             also
+                                /// this&lt;/c&gt;
+                                /// &lt;code&gt;
+                                /// line 1
+                                /// line     2
+                                /// &lt;/code&gt;
+                                /// Extra text after code.
+                                /// &lt;/summary&gt;
+                                void MyMethod() {
+                                    MyM$$ethod();
+                                }
+                            }
+                        </Document>
+                    </Project>
+                </Workspace>
+
+            Dim intellisenseQuickInfo = Await GetQuickInfoItemAsync(workspace, LanguageNames.CSharp)
+
+            Dim expected = New ContainerElement(
+                ContainerElementStyle.Stacked Or ContainerElementStyle.VerticalPadding,
+                New ContainerElement(
+                    ContainerElementStyle.Stacked,
+                    New ContainerElement(
+                        ContainerElementStyle.Wrapped,
+                        New ImageElement(New ImageId(KnownImageIds.ImageCatalogGuid, KnownImageIds.MethodPrivate)),
+                        New ClassifiedTextElement(
+                            New ClassifiedTextRun(ClassificationTypeNames.Keyword, "void"),
+                            New ClassifiedTextRun(ClassificationTypeNames.WhiteSpace, " "),
+                            New ClassifiedTextRun(ClassificationTypeNames.ClassName, "MyClass", navigationAction:=Sub() Return, "MyClass"),
+                            New ClassifiedTextRun(ClassificationTypeNames.Punctuation, "."),
+                            New ClassifiedTextRun(ClassificationTypeNames.MethodName, "MyMethod", navigationAction:=Sub() Return, "void MyClass.MyMethod()"),
+                            New ClassifiedTextRun(ClassificationTypeNames.Punctuation, "("),
+                            New ClassifiedTextRun(ClassificationTypeNames.Punctuation, ")"))),
+                   New ClassifiedTextElement(
+                       New ClassifiedTextRun(ClassificationTypeNames.Text, "Normalize this,"),
+                        New ClassifiedTextRun(ClassificationTypeNames.WhiteSpace, " "),
+                        New ClassifiedTextRun(ClassificationTypeNames.Text, "and also this", ClassifiedTextRunStyle.UseClassificationFont))),
+                New ClassifiedTextElement(
+                    New ClassifiedTextRun(ClassificationTypeNames.Text, $"line 1{vbCrLf}line     2", ClassifiedTextRunStyle.UseClassificationFont)),
+                New ClassifiedTextElement(
+                    New ClassifiedTextRun(ClassificationTypeNames.Text, "Extra text after code.")))
+
+            ToolTipAssert.EqualContent(expected, intellisenseQuickInfo.Item)
+        End Function
+    End Class
+End Namespace
diff --git a/src/EditorFeatures/Test2/IntelliSense/SignatureHelpControllerTests.vb b/src/EditorFeatures/Test2/IntelliSense/SignatureHelpControllerTests.vb
index d86ffcc83399b..3417e203d97e8 100644
--- a/src/EditorFeatures/Test2/IntelliSense/SignatureHelpControllerTests.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/SignatureHelpControllerTests.vb
@@ -191,6 +191,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
                              GetMocks(controller).PresenterSession.Verify(Sub(p) p.PresentItems(It.IsAny(Of ITrackingSpan), It.IsAny(Of IList(Of SignatureHelpItem)),
                                                                                                 It.IsAny(Of SignatureHelpItem), It.IsAny(Of Integer?)), Times.Exactly(2))
                          End Function
+
             Await worker().ConfigureAwait(False)
 
         End Function
diff --git a/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_InternalsVisibleTo.vb b/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_InternalsVisibleTo.vb
index b242ce8cddddb..fd9dd6ecc968b 100644
--- a/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_InternalsVisibleTo.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_InternalsVisibleTo.vb
@@ -161,6 +161,7 @@ End Namespace
                         state.SendInvokeCompletionList()
                         Await state.AssertSessionIsNothingOrNoCompletionItemLike("ClassLibrary1")
                     End Function
+
                 Await AssertNoCompletionAndCompletionDoesNotContainClassLibrary1()
                 state.SendTypeChars("("c)
                 Await state.AssertCompletionItemsDoNotContainAny("ClassLibrary1")
diff --git a/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_XmlDoc.vb b/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_XmlDoc.vb
index d1a0c98dfb719..d4a6efe26e574 100644
--- a/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_XmlDoc.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_XmlDoc.vb
@@ -663,6 +663,7 @@ End Class
                     Await state.AssertSelectedCompletionItem(displayText:=keyword)
                     state.SendTab()
                 End If
+
                 Await state.AssertNoCompletionSession()
 
                 ' ''' <see langword="keyword"/>$$
diff --git a/src/EditorFeatures/Test2/InteractivePaste/InteractivePasteCommandHandlerTests.vb b/src/EditorFeatures/Test2/InteractivePaste/InteractivePasteCommandHandlerTests.vb
index 41de7ce21209e..4cb6c57e81e07 100644
--- a/src/EditorFeatures/Test2/InteractivePaste/InteractivePasteCommandHandlerTests.vb
+++ b/src/EditorFeatures/Test2/InteractivePaste/InteractivePasteCommandHandlerTests.vb
@@ -236,12 +236,15 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InteractivePaste
             If includeRepl Then
                 data.SetData(InteractiveClipboardFormat.Tag, json)
             End If
+
             If isLineCopy Then
                 data.SetData(ClipboardLineBasedCutCopyTag, True)
             End If
+
             If isBoxCopy Then
                 data.SetData(BoxSelectionCutCopyTag, True)
             End If
+
             clipboard.SetDataObject(data)
         End Sub
 
diff --git a/src/EditorFeatures/Test2/NavigationBar/MockNavigationBarPresenter.vb b/src/EditorFeatures/Test2/NavigationBar/MockNavigationBarPresenter.vb
index 160317af06e3a..658b8e38c47a3 100644
--- a/src/EditorFeatures/Test2/NavigationBar/MockNavigationBarPresenter.vb
+++ b/src/EditorFeatures/Test2/NavigationBar/MockNavigationBarPresenter.vb
@@ -45,6 +45,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.NavigationBar
             If _presentItemsCallback IsNot Nothing Then
                 _presentItemsCallback()
             End If
+
             If _presentItemsWithValuesCallback IsNot Nothing Then
                 _presentItemsWithValuesCallback(projects, selectedProject, typesWithMembers, selectedType, selectedMember)
             End If
diff --git a/src/EditorFeatures/Test2/NavigationBar/NavigationBarPresenterTests.vb b/src/EditorFeatures/Test2/NavigationBar/NavigationBarPresenterTests.vb
index cfb2f43dd403a..d11df11f74712 100644
--- a/src/EditorFeatures/Test2/NavigationBar/NavigationBarPresenterTests.vb
+++ b/src/EditorFeatures/Test2/NavigationBar/NavigationBarPresenterTests.vb
@@ -117,8 +117,6 @@ class C
                 Dim controllerFactory = workspace.GetService(Of INavigationBarControllerFactoryService)()
                 Dim controller = controllerFactory.CreateController(mockPresenter, baseDocument.GetTextBuffer())
 
-                controller.SetWorkspace(workspace)
-
                 Dim listenerProvider = workspace.ExportProvider.GetExport(Of IAsynchronousOperationListenerProvider).Value
                 Dim workspaceWaiter = listenerProvider.GetWaiter(FeatureAttribute.Workspace)
                 Dim navbarWaiter = listenerProvider.GetWaiter(FeatureAttribute.NavigationBar)
@@ -186,8 +184,6 @@ End Class
                 Dim controllerFactory = workspace.GetService(Of INavigationBarControllerFactoryService)()
                 Dim controller = controllerFactory.CreateController(mockPresenter, baseDocument.GetTextBuffer())
 
-                controller.SetWorkspace(workspace)
-
                 Dim listenerProvider = workspace.ExportProvider.GetExport(Of IAsynchronousOperationListenerProvider).Value
                 Dim workspaceWaiter = listenerProvider.GetWaiter(FeatureAttribute.Workspace)
                 Dim navbarWaiter = listenerProvider.GetWaiter(FeatureAttribute.NavigationBar)
@@ -324,7 +320,6 @@ End Class
 
                 Dim controllerFactory = workspace.GetService(Of INavigationBarControllerFactoryService)()
                 Dim controller = controllerFactory.CreateController(mockPresenter, document.GetTextBuffer())
-                controller.SetWorkspace(workspace)
 
                 mockPresenter.RaiseDropDownFocused()
                 Assert.Equal("VBProj", projectName)
diff --git a/src/EditorFeatures/Test2/NavigationBar/TestHelpers.vb b/src/EditorFeatures/Test2/NavigationBar/TestHelpers.vb
index c408f4ca61337..0e2fbcb18e492 100644
--- a/src/EditorFeatures/Test2/NavigationBar/TestHelpers.vb
+++ b/src/EditorFeatures/Test2/NavigationBar/TestHelpers.vb
@@ -59,7 +59,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.NavigationBar
                 Dim items = Await service.GetItemsAsync(document, snapshot, Nothing)
 
                 Dim hostDocument = workspace.Documents.Single(Function(d) d.CursorPosition.HasValue)
-                Dim model As New NavigationBarModel(items.ToImmutableArray(), VersionStamp.Create(), service)
+                Dim model As New NavigationBarModel(items.ToImmutableArray(), service)
                 Dim selectedItems = NavigationBarController.ComputeSelectedTypeAndMember(model, New SnapshotPoint(hostDocument.GetTextBuffer().CurrentSnapshot, hostDocument.CursorPosition.Value), Nothing)
 
                 Dim isCaseSensitive = document.GetLanguageService(Of ISyntaxFactsService)().IsCaseSensitive
diff --git a/src/EditorFeatures/Test2/Rename/RenameEngineResult.vb b/src/EditorFeatures/Test2/Rename/RenameEngineResult.vb
index 260a14bb4a1bf..22c182bb65c00 100644
--- a/src/EditorFeatures/Test2/Rename/RenameEngineResult.vb
+++ b/src/EditorFeatures/Test2/Rename/RenameEngineResult.vb
@@ -109,6 +109,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Rename
                 Else
                     workspace.Dispose()
                 End If
+
                 Throw
             End Try
 
diff --git a/src/EditorFeatures/Test2/Rename/RenameTagProducerTests.vb b/src/EditorFeatures/Test2/Rename/RenameTagProducerTests.vb
index cd00dad929025..5685ad4f6db0d 100644
--- a/src/EditorFeatures/Test2/Rename/RenameTagProducerTests.vb
+++ b/src/EditorFeatures/Test2/Rename/RenameTagProducerTests.vb
@@ -54,6 +54,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Rename
                                                                    If kvp.Key = annotationString Then
                                                                        Return kvp.Value.Select(Function(ts) ts.ToSpan())
                                                                    End If
+
                                                                    Return SpecializedCollections.EmptyEnumerable(Of Span)
                                                                End Function)
         End Function
diff --git a/src/EditorFeatures/Test2/Simplification/AbstractSimplificationTests.vb b/src/EditorFeatures/Test2/Simplification/AbstractSimplificationTests.vb
index da51334eba84b..4a23a6a4834a2 100644
--- a/src/EditorFeatures/Test2/Simplification/AbstractSimplificationTests.vb
+++ b/src/EditorFeatures/Test2/Simplification/AbstractSimplificationTests.vb
@@ -31,6 +31,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Simplification
                     workspace.ChangeSolution(workspace.CurrentSolution.WithProjectParseOptions(project.Id, csharpParseOptions))
                 Next
             End If
+
             Return workspace
         End Function
 
@@ -135,6 +136,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Simplification
                     Exit While
                 End If
             End While
+
             Return node
         End Function
 
diff --git a/src/EditorFeatures/TestUtilities/Classification/FormattedClassification.cs b/src/EditorFeatures/TestUtilities/Classification/FormattedClassification.cs
index 02c112ab14f16..8a023df776fb1 100644
--- a/src/EditorFeatures/TestUtilities/Classification/FormattedClassification.cs
+++ b/src/EditorFeatures/TestUtilities/Classification/FormattedClassification.cs
@@ -66,6 +66,7 @@ public override string ToString()
                         case ",":
                             return "Punctuation.Comma";
                     }
+
                     goto default;
 
                 case "operator":
@@ -76,6 +77,7 @@ public override string ToString()
                         case "++":
                             return "Operators.PlusPlus";
                     }
+
                     goto default;
 
                 default:
diff --git a/src/EditorFeatures/TestUtilities/Diagnostics/GenerateType/TestGenerateTypeOptionsService.cs b/src/EditorFeatures/TestUtilities/Diagnostics/GenerateType/TestGenerateTypeOptionsService.cs
index 58da93e20c6d4..6d71e27b24d19 100644
--- a/src/EditorFeatures/TestUtilities/Diagnostics/GenerateType/TestGenerateTypeOptionsService.cs
+++ b/src/EditorFeatures/TestUtilities/Diagnostics/GenerateType/TestGenerateTypeOptionsService.cs
@@ -56,6 +56,7 @@ public GenerateTypeOptionsResult GetGenerateTypeOptions(
             {
                 DefaultNamespace = projectManagementService.GetDefaultNamespace(Project, Project?.Solution.Workspace);
             }
+
             return new GenerateTypeOptionsResult(
                 accessibility: Accessibility,
                 typeKind: TypeKind,
diff --git a/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs b/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs
index fe39597f7c5a2..88b41f12b85b4 100644
--- a/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs
+++ b/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs
@@ -24,11 +24,17 @@ namespace Microsoft.CodeAnalysis.EditAndContinue.UnitTests
     internal abstract class EditAndContinueTestHelpers
     {
         public static readonly EditAndContinueCapabilities BaselineCapabilities = EditAndContinueCapabilities.Baseline;
-        public static readonly EditAndContinueCapabilities Net5RuntimeCapabilities = EditAndContinueCapabilities.Baseline |
-                                                                                     EditAndContinueCapabilities.AddInstanceFieldToExistingType |
-                                                                                     EditAndContinueCapabilities.AddStaticFieldToExistingType |
-                                                                                     EditAndContinueCapabilities.AddMethodToExistingType |
-                                                                                     EditAndContinueCapabilities.NewTypeDefinition;
+
+        public static readonly EditAndContinueCapabilities Net5RuntimeCapabilities =
+            EditAndContinueCapabilities.Baseline |
+            EditAndContinueCapabilities.AddInstanceFieldToExistingType |
+            EditAndContinueCapabilities.AddStaticFieldToExistingType |
+            EditAndContinueCapabilities.AddMethodToExistingType |
+            EditAndContinueCapabilities.NewTypeDefinition;
+
+        public static readonly EditAndContinueCapabilities Net6RuntimeCapabilities =
+            Net5RuntimeCapabilities |
+            EditAndContinueCapabilities.ChangeCustomAttributes;
 
         public abstract AbstractEditAndContinueAnalyzer Analyzer { get; }
         public abstract SyntaxNode FindNode(SyntaxNode root, TextSpan span);
diff --git a/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs b/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
index 347ddf2d2d659..988a4ea86afb6 100644
--- a/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
+++ b/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
@@ -40,6 +40,7 @@ public abstract class AbstractLanguageServerProtocolTests
         private static readonly TestComposition s_composition = EditorTestCompositions.LanguageServerProtocolWpf
             .AddParts(typeof(TestLspWorkspaceRegistrationService))
             .AddParts(typeof(TestDocumentTrackingService))
+            .AddParts(typeof(TestExperimentationService))
             .RemoveParts(typeof(MockWorkspaceEventListenerProvider));
 
         [Export(typeof(ILspWorkspaceRegistrationService)), PartNotDiscoverable]
@@ -411,6 +412,49 @@ private static RequestExecutionQueue CreateRequestQueue(TestWorkspace workspace)
         private static string GetDocumentFilePathFromName(string documentName)
             => "C:\\" + documentName;
 
+        private static LSP.DidChangeTextDocumentParams CreateDidChangeTextDocumentParams(
+            Uri documentUri,
+            ImmutableArray<(int startLine, int startColumn, int endLine, int endColumn, string text)> changes)
+        {
+            var changeEvents = changes.Select(change => new LSP.TextDocumentContentChangeEvent
+            {
+                Text = change.text,
+                Range = new LSP.Range
+                {
+                    Start = new LSP.Position(change.startLine, change.startColumn),
+                    End = new LSP.Position(change.endLine, change.endColumn)
+                }
+            }).ToArray();
+
+            return new LSP.DidChangeTextDocumentParams()
+            {
+                TextDocument = new LSP.VersionedTextDocumentIdentifier
+                {
+                    Uri = documentUri
+                },
+                ContentChanges = changeEvents
+            };
+        }
+
+        private static LSP.DidOpenTextDocumentParams CreateDidOpenTextDocumentParams(Uri uri, string source)
+            => new LSP.DidOpenTextDocumentParams
+            {
+                TextDocument = new LSP.TextDocumentItem
+                {
+                    Text = source,
+                    Uri = uri
+                }
+            };
+
+        private static LSP.DidCloseTextDocumentParams CreateDidCloseTextDocumentParams(Uri uri)
+           => new LSP.DidCloseTextDocumentParams()
+           {
+               TextDocument = new LSP.TextDocumentIdentifier
+               {
+                   Uri = uri
+               }
+           };
+
         public sealed class TestLspServer : IDisposable
         {
             public readonly TestWorkspace TestWorkspace;
@@ -431,6 +475,41 @@ public Task<ResponseType> ExecuteRequestAsync<RequestType, ResponseType>(string
                     _executionQueue, methodName, request, clientCapabilities, clientName, cancellationToken);
             }
 
+            public async Task OpenDocumentAsync(Uri documentUri)
+            {
+                // LSP open files don't care about the project context, just the file contents with the URI.
+                // So pick any of the linked documents to get the text from.
+                var text = await TestWorkspace.CurrentSolution.GetDocuments(documentUri).First().GetTextAsync(CancellationToken.None).ConfigureAwait(false);
+                var didOpenParams = CreateDidOpenTextDocumentParams(documentUri, text.ToString());
+                await ExecuteRequestAsync<LSP.DidOpenTextDocumentParams, object>(LSP.Methods.TextDocumentDidOpenName,
+                           didOpenParams, new LSP.ClientCapabilities(), null, CancellationToken.None);
+            }
+
+            public Task InsertTextAsync(Uri documentUri, params (int line, int column, string text)[] changes)
+            {
+                var didChangeParams = CreateDidChangeTextDocumentParams(
+                    documentUri,
+                    changes.Select(change => (startLine: change.line, startColumn: change.column, endLine: change.line, endColumn: change.column, change.text)).ToImmutableArray());
+                return ExecuteRequestAsync<LSP.DidChangeTextDocumentParams, object>(LSP.Methods.TextDocumentDidChangeName,
+                           didChangeParams, new LSP.ClientCapabilities(), clientName: null, CancellationToken.None);
+            }
+
+            public Task DeleteTextAsync(Uri documentUri, params (int startLine, int startColumn, int endLine, int endColumn)[] changes)
+            {
+                var didChangeParams = CreateDidChangeTextDocumentParams(
+                    documentUri,
+                    changes.Select(change => (change.startLine, change.startColumn, change.endLine, change.endColumn, text: string.Empty)).ToImmutableArray());
+                return ExecuteRequestAsync<LSP.DidChangeTextDocumentParams, object>(LSP.Methods.TextDocumentDidChangeName,
+                           didChangeParams, new LSP.ClientCapabilities(), null, CancellationToken.None);
+            }
+
+            public Task CloseDocumentAsync(Uri documentUri)
+            {
+                var didCloseParams = CreateDidCloseTextDocumentParams(documentUri);
+                return ExecuteRequestAsync<LSP.DidCloseTextDocumentParams, object>(LSP.Methods.TextDocumentDidCloseName,
+                           didCloseParams, new LSP.ClientCapabilities(), null, CancellationToken.None);
+            }
+
             public Solution GetCurrentSolution() => TestWorkspace.CurrentSolution;
 
             internal RequestExecutionQueue.TestAccessor GetQueueAccessor() => _executionQueue.GetTestAccessor();
diff --git a/src/EditorFeatures/TestUtilities2/Intellisense/MockCompletionPresenterProvider.vb b/src/EditorFeatures/TestUtilities2/Intellisense/MockCompletionPresenterProvider.vb
index 17d6077d70538..cc52445075dbe 100644
--- a/src/EditorFeatures/TestUtilities2/Intellisense/MockCompletionPresenterProvider.vb
+++ b/src/EditorFeatures/TestUtilities2/Intellisense/MockCompletionPresenterProvider.vb
@@ -37,6 +37,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
             If Not _presenters.ContainsKey(textView) Then
                 _presenters(textView) = New MockCompletionPresenter(textView)
             End If
+
             Return _presenters(textView)
         End Function
     End Class
diff --git a/src/EditorFeatures/TestUtilities2/Intellisense/TestState.vb b/src/EditorFeatures/TestUtilities2/Intellisense/TestState.vb
index 42721cc4584c3..851f6c629ba33 100644
--- a/src/EditorFeatures/TestUtilities2/Intellisense/TestState.vb
+++ b/src/EditorFeatures/TestUtilities2/Intellisense/TestState.vb
@@ -249,6 +249,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
                                                        End Sub)
                                           End If
                                       End Sub
+
             Dim sessionDismissedHandler = Sub(sender As Object, e As EventArgs) sessionComplete.TrySetResult(Nothing)
 
             Dim session As IAsyncCompletionSession
diff --git a/src/EditorFeatures/Text/Microsoft.CodeAnalysis.EditorFeatures.Text.csproj b/src/EditorFeatures/Text/Microsoft.CodeAnalysis.EditorFeatures.Text.csproj
index 98ac2d73b3bf1..e5cccc88f95fc 100644
--- a/src/EditorFeatures/Text/Microsoft.CodeAnalysis.EditorFeatures.Text.csproj
+++ b/src/EditorFeatures/Text/Microsoft.CodeAnalysis.EditorFeatures.Text.csproj
@@ -5,7 +5,7 @@
     <OutputType>Library</OutputType>
     <RootNamespace>Microsoft.CodeAnalysis.Text</RootNamespace>
     <TargetFrameworks>netcoreapp3.1;netstandard2.0</TargetFrameworks>
-    <ApplyNgenOptimization>partial</ApplyNgenOptimization>
+    <ApplyNgenOptimization Condition="'$(TargetFramework)' == 'netstandard2.0'">partial</ApplyNgenOptimization>
 
     <!-- NuGet -->
     <IsPackable>true</IsPackable>
diff --git a/src/EditorFeatures/VisualBasic/EndConstructGeneration/EndConstructExtensions.vb b/src/EditorFeatures/VisualBasic/EndConstructGeneration/EndConstructExtensions.vb
index 2836e02d7c4a4..034f0679331a8 100644
--- a/src/EditorFeatures/VisualBasic/EndConstructGeneration/EndConstructExtensions.vb
+++ b/src/EditorFeatures/VisualBasic/EndConstructGeneration/EndConstructExtensions.vb
@@ -13,6 +13,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.EndConstructGeneration
             If snapshot Is Nothing Then
                 Throw New ArgumentNullException(NameOf(snapshot))
             End If
+
             Dim line = snapshot.GetLineFromPosition(position)
             Dim precedingText = snapshot.GetText(Span.FromBounds(line.Start, position))
 
diff --git a/src/EditorFeatures/VisualBasic/EndConstructGeneration/VisualBasicEndConstructGenerationService.vb b/src/EditorFeatures/VisualBasic/EndConstructGeneration/VisualBasicEndConstructGenerationService.vb
index b8ab1ae14e182..c4ef6e59106d3 100644
--- a/src/EditorFeatures/VisualBasic/EndConstructGeneration/VisualBasicEndConstructGenerationService.vb
+++ b/src/EditorFeatures/VisualBasic/EndConstructGeneration/VisualBasicEndConstructGenerationService.vb
@@ -363,6 +363,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.EndConstructGeneration
                 If errors.Count <> 1 Then
                     Return False
                 End If
+
                 If Not IsExpectedXmlEndCDataError(errors(0).Id) Then
                     Return False
                 End If
@@ -390,6 +391,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.EndConstructGeneration
                 If errors.Count <> 1 Then
                     Return False
                 End If
+
                 If Not IsExpectedXmlEndCommentError(errors(0).Id) Then
                     Return False
                 End If
@@ -417,6 +419,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.EndConstructGeneration
                 If errors.Count <> 1 Then
                     Return False
                 End If
+
                 If Not IsMissingXmlEndTagError(errors(0).Id) Then
                     Return False
                 End If
@@ -468,6 +471,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.EndConstructGeneration
                 If errors.Count <> 2 Then
                     Return False
                 End If
+
                 If Not (errors.Any(Function(e) IsExpectedXmlNameError(e.Id)) AndAlso
                         errors.Any(Function(e) IsExpectedXmlEndPIError(e.Id))) Then
                     Return False
diff --git a/src/EditorFeatures/VisualBasic/Highlighting/KeywordHighlighters/TryBlockHighlighter.vb b/src/EditorFeatures/VisualBasic/Highlighting/KeywordHighlighters/TryBlockHighlighter.vb
index dcff6f2786ca5..05d606df0f3db 100644
--- a/src/EditorFeatures/VisualBasic/Highlighting/KeywordHighlighters/TryBlockHighlighter.vb
+++ b/src/EditorFeatures/VisualBasic/Highlighting/KeywordHighlighters/TryBlockHighlighter.vb
@@ -42,6 +42,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.KeywordHighlighting
                             highlights.Add(.WhenClause.WhenKeyword.Span)
                         End If
                     End With
+
                     HighlightRelatedStatements(catchBlock, highlights)
                 Next
 
diff --git a/src/EditorFeatures/VisualBasic/Highlighting/KeywordHighlighters/XmlElementHighlighter.vb b/src/EditorFeatures/VisualBasic/Highlighting/KeywordHighlighters/XmlElementHighlighter.vb
index 172c51b171684..c09dfc1d81a1b 100644
--- a/src/EditorFeatures/VisualBasic/Highlighting/KeywordHighlighters/XmlElementHighlighter.vb
+++ b/src/EditorFeatures/VisualBasic/Highlighting/KeywordHighlighters/XmlElementHighlighter.vb
@@ -34,6 +34,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.KeywordHighlighting
                             highlights.Add(.GreaterThanToken.Span)
                         End If
                     End With
+
                     highlights.Add(.EndTag.Span)
                 End If
 
diff --git a/src/EditorFeatures/VisualBasic/LineSeparators/VisualBasicLineSeparatorService.vb b/src/EditorFeatures/VisualBasic/LineSeparators/VisualBasicLineSeparatorService.vb
index 04ab654c141d7..2d7233579bbc9 100644
--- a/src/EditorFeatures/VisualBasic/LineSeparators/VisualBasicLineSeparatorService.vb
+++ b/src/EditorFeatures/VisualBasic/LineSeparators/VisualBasicLineSeparatorService.vb
@@ -114,6 +114,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineSeparators
                         Dim prev = children(i - 1)
                         spans.Add(GetLineSeparatorSpanForNode(prev))
                     End If
+
                     spans.Add(GetLineSeparatorSpanForNode(cur))
 
                     seenSeparator = True
@@ -128,6 +129,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineSeparators
                     Dim nextToLast = children(children.Count - 2)
                     spans.Add(GetLineSeparatorSpanForNode(nextToLast))
                 End If
+
                 If lastChild.Parent.Kind = SyntaxKind.CompilationUnit Then
                     spans.Add(GetLineSeparatorSpanForNode(lastChild))
                 End If
diff --git a/src/EditorFeatures/VisualBasic/Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.vbproj b/src/EditorFeatures/VisualBasic/Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.vbproj
index 9a3cb1ca4f787..528fe72cace76 100644
--- a/src/EditorFeatures/VisualBasic/Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.vbproj
+++ b/src/EditorFeatures/VisualBasic/Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.vbproj
@@ -5,7 +5,7 @@
     <OutputType>Library</OutputType>
     <TargetFrameworks>netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <RootNamespace></RootNamespace>
-    <ApplyNgenOptimization>partial</ApplyNgenOptimization>
+    <ApplyNgenOptimization Condition="'$(TargetFramework)' == 'netstandard2.0'">partial</ApplyNgenOptimization>
     <!-- NuGet -->
     <IsPackable>true</IsPackable>
     <PackageDescription>
diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/IntroduceParameter/IntroduceParameterTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/IntroduceParameter/IntroduceParameterTests.vb
index c55b3c42b7b87..b69c77b032198 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/IntroduceParameter/IntroduceParameterTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CodeActions/IntroduceParameter/IntroduceParameterTests.vb
@@ -931,6 +931,18 @@ End Class"
 
             Await TestInRegularAndScriptAsync(source, expected, index:=1)
         End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceParameter)>
+        Public Async Function TestHighlightReturnType() As Task
+            Dim source =
+"Class Program
+    Public Function M(x As Integer) As [|Integer|]
+        Return x
+    End Function
+End Class"
+
+            Await TestMissingInRegularAndScriptAsync(source)
+        End Function
     End Class
 End Namespace
 
diff --git a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/AbstractVisualBasicCompletionProviderTests.vb b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/AbstractVisualBasicCompletionProviderTests.vb
index 276120645efd8..1f0dfb55aaa06 100644
--- a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/AbstractVisualBasicCompletionProviderTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/AbstractVisualBasicCompletionProviderTests.vb
@@ -89,6 +89,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Completion.Complet
             If expectedItemOrNull(0) = "[" Then
                 Return expectedItemOrNull.Substring(1, 1)
             End If
+
             Return expectedItemOrNull.Substring(0, 1)
         End Function
 
diff --git a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/SymbolCompletionProviderTests.vb b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/SymbolCompletionProviderTests.vb
index d9003472ed7e5..348edfce5540e 100644
--- a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/SymbolCompletionProviderTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/SymbolCompletionProviderTests.vb
@@ -6340,6 +6340,34 @@ End Class]]></code>.Value
             Await VerifyItemExistsAsync(text, "ToString")
         End Function
 
+        <WorkItem(54361, "https://github.com/dotnet/roslyn/issues/54361")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function TestConditionalOperatorCompletionForNullableParameterSymbols_1() As Task
+            Dim text =
+<code><![CDATA[
+Class [Class]
+    Sub Goo(dt As System.DateTime?)
+        dt?.$$
+    End Sub
+End Class]]></code>.Value
+            Await VerifyItemExistsAsync(text, "Day")
+            Await VerifyItemIsAbsentAsync(text, "Value")
+        End Function
+
+        <WorkItem(54361, "https://github.com/dotnet/roslyn/issues/54361")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function TestConditionalOperatorCompletionForNullableParameterSymbols_2() As Task
+            Dim text =
+<code><![CDATA[
+Class [Class]
+    Sub Goo(dt As System.DateTime?)
+        dt.$$
+    End Sub
+End Class]]></code>.Value
+            Await VerifyItemExistsAsync(text, "Value")
+            Await VerifyItemIsAbsentAsync(text, "Day")
+        End Function
+
         <WorkItem(1041269, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1041269")>
         <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
         Public Async Function TestHidePropertyBackingFieldAndEventsAtExpressionLevel() As Task
@@ -7750,6 +7778,7 @@ End Namespace
             For index = 2 To 8
                 Await VerifyItemExistsAsync(text, "Item" + index.ToString())
             Next
+
             Await VerifyItemExistsAsync(text, "ToString")
 
             Await VerifyItemIsAbsentAsync(text, "Item1")
diff --git a/src/EditorFeatures/VisualBasicTest/EditAndContinue/ActiveStatementTests.vb b/src/EditorFeatures/VisualBasicTest/EditAndContinue/ActiveStatementTests.vb
index aecb17e8655b2..1a465c7cc1b3a 100644
--- a/src/EditorFeatures/VisualBasicTest/EditAndContinue/ActiveStatementTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/EditAndContinue/ActiveStatementTests.vb
@@ -1945,7 +1945,7 @@ End Class
             Dim active = GetActiveStatements(src1, src2)
 
             edits.VerifyRudeDiagnostics(active,
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Private Const a As Integer = 1", FeaturesResources.const_field))
+                Diagnostic(RudeEditKind.ModifiersUpdate, "a As Integer = 1", FeaturesResources.const_field))
         End Sub
 
         <Fact>
@@ -1990,7 +1990,7 @@ End Class
             Dim active = GetActiveStatements(src1, src2)
 
             edits.VerifyRudeDiagnostics(active,
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Private Const a As Integer = 1, b As Integer = 2", FeaturesResources.const_field))
+                Diagnostic(RudeEditKind.ModifiersUpdate, "a As Integer = 1", FeaturesResources.const_field))
         End Sub
 
         <Fact>
diff --git a/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb b/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb
index c2c191621330f..5a6a8a423c7ee 100644
--- a/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb
+++ b/src/EditorFeatures/VisualBasicTest/EditAndContinue/Helpers/EditingTestBase.vb
@@ -29,6 +29,21 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue.UnitTests
             Iterator
         End Enum
 
+        Public Shared Function GetResource(keyword As String) As String
+            Select Case keyword
+                Case "Class"
+                    Return FeaturesResources.class_
+                Case "Structure"
+                    Return VBFeaturesResources.structure_
+                Case "Module"
+                    Return VBFeaturesResources.module_
+                Case "Interface"
+                    Return FeaturesResources.interface_
+                Case Else
+                    Throw ExceptionUtilities.UnexpectedValue(keyword)
+            End Select
+        End Function
+
         Friend Shared NoSemanticEdits As SemanticEditDescription() = Array.Empty(Of SemanticEditDescription)
 
         Friend Overloads Shared Function Diagnostic(rudeEditKind As RudeEditKind, squiggle As String, ParamArray arguments As String()) As RudeEditDiagnosticDescription
diff --git a/src/EditorFeatures/VisualBasicTest/EditAndContinue/TopLevelEditingTests.vb b/src/EditorFeatures/VisualBasicTest/EditAndContinue/TopLevelEditingTests.vb
index 519ab947a0a8d..976d8b43337a6 100644
--- a/src/EditorFeatures/VisualBasicTest/EditAndContinue/TopLevelEditingTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/EditAndContinue/TopLevelEditingTests.vb
@@ -281,51 +281,6 @@ Option Strict Off
 #End Region
 
 #Region "Attributes"
-        <Fact>
-        Public Sub UpdateAttributes1()
-            Dim attribute = "Public Class A1Attribute : Inherits System.Attribute : End Class" & vbCrLf &
-                            "Public Class A2Attribute : Inherits System.Attribute : End Class" & vbCrLf
-
-            Dim src1 = attribute & "<A1>Class C : End Class"
-            Dim src2 = attribute & "<A2>Class C : End Class"
-
-            Dim edits = GetTopEdits(src1, src2)
-            edits.VerifyEdits(
-                "Update [<A1>Class C]@132 -> [<A2>Class C]@132")
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "Class C", FeaturesResources.class_))
-        End Sub
-
-        <Fact>
-        Public Sub UpdateAttributes2()
-            Dim src1 = "<System.Obsolete(""1"")>Class C : End Class"
-            Dim src2 = "<System.Obsolete(""2"")>Class C : End Class"
-            Dim edits = GetTopEdits(src1, src2)
-
-            edits.VerifyEdits(
-                "Update [<System.Obsolete(""1"")>Class C]@0 -> [<System.Obsolete(""2"")>Class C]@0")
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "Class C", FeaturesResources.class_))
-        End Sub
-
-        <Fact>
-        Public Sub UpdateAttributes3()
-            Dim attribute = "Public Class A1Attribute : Inherits System.Attribute : End Class" & vbCrLf &
-                            "Public Class A2Attribute : Inherits System.Attribute : End Class" & vbCrLf
-
-            Dim src1 = attribute & "<A1>Module C : End Module"
-            Dim src2 = attribute & "<A2>Module C : End Module"
-
-            Dim edits = GetTopEdits(src1, src2)
-            edits.VerifyEdits(
-                "Update [<A1>Module C]@132 -> [<A2>Module C]@132")
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "Module C", VBFeaturesResources.module_))
-        End Sub
-
         <Fact>
         Public Sub UpdateAttributes_TopLevel1()
             Dim src1 = "<Assembly: A(1)>"
@@ -472,119 +427,173 @@ Option Strict Off
 
 #End Region
 
-#Region "Top-level Classes, Structs, Interfaces, Modules"
-        <Fact>
-        Public Sub ClassInsert()
-            Dim src1 = ""
-            Dim src2 = "Class C : End Class"
+#Region "Types"
+        <Theory>
+        <InlineData("Class", "Structure")>
+        <InlineData("Class", "Module")>
+        <InlineData("Class", "Interface")>
+        Public Sub Type_Kind_Update(oldKeyword As String, newKeyword As String)
+            Dim src1 = oldKeyword & " C : End " & oldKeyword
+            Dim src2 = newKeyword & " C : End " & newKeyword
             Dim edits = GetTopEdits(src1, src2)
 
-            edits.VerifyRudeDiagnostics()
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.TypeKindUpdate, newKeyword & " C"))
         End Sub
 
-        <Fact>
-        Public Sub StructInsert()
-            Dim src1 = ""
-            Dim src2 = "Structure C : End Structure"
-            Dim edits = GetTopEdits(src1, src2)
+        <Theory>
+        <InlineData("Public")>
+        Public Sub Type_Modifiers_Accessibility_Change(accessibility As String)
 
-            edits.VerifyRudeDiagnostics()
-        End Sub
+            Dim src1 = accessibility + " Class C : End Class"
+            Dim src2 = "Class C : End Class"
 
-        <Fact>
-        Public Sub PartialInterfaceInsert()
-            Dim src1 = ""
-            Dim src2 = "Partial Interface C : End Interface"
             Dim edits = GetTopEdits(src1, src2)
 
-            edits.VerifySemantics(semanticEdits:=
-            {
-                SemanticEdit(SemanticEditKind.Insert, Function(c) c.GetMember("C"))
-            })
+            edits.VerifyEdits(
+                "Update [" + accessibility + " Class C]@0 -> [Class C]@0")
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingAccessibility, "Class C", FeaturesResources.class_))
         End Sub
 
-        <Fact>
-        Public Sub PartialInterfaceDelete()
-            Dim src1 = "Partial Interface C : End Interface"
-            Dim src2 = ""
-            Dim edits = GetTopEdits(src1, src2)
+        <Theory>
+        <InlineData("Public", "Public")>
+        <InlineData("Friend", "Friend")>
+        <InlineData("", "Friend")>
+        <InlineData("Friend", "")>
+        <InlineData("Protected", "Protected")>
+        <InlineData("Private", "Private")>
+        <InlineData("Private Protected", "Private Protected")>
+        <InlineData("Friend Protected", "Friend Protected")>
+        Public Sub Type_Modifiers_Accessibility_Partial(accessibilityA As String, accessibilityB As String)
+
+            Dim srcA1 = accessibilityA + " Partial Class C : End Class"
+            Dim srcB1 = "Partial Class C : End Class"
+            Dim srcA2 = "Partial Class C : End Class"
+            Dim srcB2 = accessibilityB + " Partial Class C : End Class"
 
-            edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.Delete, Nothing, DeletedSymbolDisplay(FeaturesResources.interface_, "C")))
+            EditAndContinueValidation.VerifySemantics(
+                {GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2)},
+                {
+                    DocumentResults(),
+                    DocumentResults()
+                })
         End Sub
 
-        <Fact>
-        Public Sub ModuleInsert()
-            Dim src1 = ""
-            Dim src2 = "Module C : End Module"
-            Dim edits = GetTopEdits(src1, src2)
+        <Theory>
+        <InlineData("Class")>
+        <InlineData("Structure")>
+        <InlineData("Module")>
+        <InlineData("Interface")>
+        Public Sub Type_Modifiers_Friend_Remove(keyword As String)
+            Dim src1 = "Friend " & keyword & " C : End " & keyword
+            Dim src2 = keyword & " C : End " & keyword
 
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.Insert, "Module C", VBFeaturesResources.module_))
+            Dim edits = GetTopEdits(src1, src2)
+            edits.VerifySemantics()
         End Sub
 
-        <Fact>
-        Public Sub PartialModuleInsert()
-            Dim src1 = ""
-            Dim src2 = "Partial Module C : End Module"
+        <Theory>
+        <InlineData("Class")>
+        <InlineData("Structure")>
+        <InlineData("Module")>
+        <InlineData("Interface")>
+        Public Sub Type_Modifiers_Friend_Add(keyword As String)
+            Dim src1 = keyword & " C : End " & keyword
+            Dim src2 = "Friend " & keyword & " C : End " & keyword
+
             Dim edits = GetTopEdits(src1, src2)
+            edits.VerifySemantics()
+        End Sub
+
+        <Theory>
+        <InlineData("Class")>
+        <InlineData("Structure")>
+        <InlineData("Interface")>
+        Public Sub Type_Modifiers_NestedPrivateInInterface_Remove(keyword As String)
+            Dim src1 = "Interface C : Private " & keyword & " S : End " & keyword & " : End Interface"
+            Dim src2 = "Interface C : " & keyword & " S : End " & keyword & " : End Interface"
 
+            Dim edits = GetTopEdits(src1, src2)
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.Insert, "Partial Module C", VBFeaturesResources.module_))
+                Diagnostic(RudeEditKind.ChangingAccessibility, keyword + " S", GetResource(keyword)))
         End Sub
 
-        <Fact>
-        Public Sub PartialModuleDelete()
-            Dim src1 = "Partial Module C : End Module"
-            Dim src2 = ""
+        <Theory>
+        <InlineData("Class")>
+        <InlineData("Structure")>
+        <InlineData("Interface")>
+        Public Sub Type_Modifiers_NestedPublicInClass_Add(keyword As String)
+            Dim src1 = "Class C : " & keyword & " S : End " & keyword & " : End Class"
+            Dim src2 = "Class C : Public " & keyword & " S : End " & keyword & " : End Class"
+
             Dim edits = GetTopEdits(src1, src2)
+            edits.VerifySemantics()
+        End Sub
 
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.Delete, Nothing, DeletedSymbolDisplay(VBFeaturesResources.module_, "C")))
+        <Theory>
+        <InlineData("Class")>
+        <InlineData("Structure")>
+        <InlineData("Interface")>
+        Public Sub Type_Modifiers_NestedPublicInInterface_Add(keyword As String)
+            Dim src1 = "Interface I : " + keyword + " S : End " & keyword & " : End Interface"
+            Dim src2 = "Interface I : Public " + keyword + " S : End " & keyword & " : End Interface"
+            Dim edits = GetTopEdits(src1, src2)
+            edits.VerifySemantics()
         End Sub
 
         <Fact>
-        Public Sub TypeKindChange1()
-            Dim src1 = "Class C : End Class"
-            Dim src2 = "Structure C : End Structure"
-            Dim edits = GetTopEdits(src1, src2)
+        Public Sub Type_Attribute_Update_NotSupportedByRuntime1()
+            Dim attribute = "Public Class A1Attribute : Inherits System.Attribute : End Class" & vbCrLf &
+                            "Public Class A2Attribute : Inherits System.Attribute : End Class" & vbCrLf
+
+            Dim src1 = attribute & "<A1>Class C : End Class"
+            Dim src2 = attribute & "<A2>Class C : End Class"
 
+            Dim edits = GetTopEdits(src1, src2)
             edits.VerifyEdits(
-                "Update [Class C : End Class]@0 -> [Structure C : End Structure]@0",
-                "Update [Class C]@0 -> [Structure C]@0")
+                "Update [<A1>Class C]@132 -> [<A2>Class C]@132")
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.TypeKindUpdate, "Structure C", VBFeaturesResources.structure_))
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "Class C", FeaturesResources.class_))
         End Sub
 
-        <Fact>
-        Public Sub TypeKindChange2()
-            Dim src1 = "Public Module C : End Module"
-            Dim src2 = "Public Class C : End Class"
+        <Theory>
+        <InlineData("Module")>
+        <InlineData("Class")>
+        <InlineData("Structure")>
+        <InlineData("Interface")>
+        Public Sub Type_Attribute_Update_NotSupportedByRuntime(keyword As String)
+            Dim src1 = "<System.Obsolete(""1"")>" & keyword & " C : End " & keyword
+            Dim src2 = "<System.Obsolete(""2"")>" & keyword & " C : End " & keyword
             Dim edits = GetTopEdits(src1, src2)
 
             edits.VerifyEdits(
-                "Update [Public Module C : End Module]@0 -> [Public Class C : End Class]@0",
-                "Update [Public Module C]@0 -> [Public Class C]@0")
+                "Update [<System.Obsolete(""1"")>" & keyword & " C]@0 -> [<System.Obsolete(""2"")>" & keyword & " C]@0")
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.TypeKindUpdate, "Public Class C", FeaturesResources.class_))
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, keyword & " C", GetResource(keyword)))
         End Sub
 
-        <Fact>
-        Public Sub ModuleModifiersUpdate()
-            Dim src1 = "Module C : End Module"
-            Dim src2 = "Partial Module C : End Module"
+        <Theory>
+        <InlineData("Module")>
+        <InlineData("Class")>
+        <InlineData("Structure")>
+        <InlineData("Interface")>
+        Public Sub Type_PartialModifier_Add(keyword As String)
+            Dim src1 = keyword & " C : End " & keyword
+            Dim src2 = "Partial " & keyword & " C : End " & keyword
             Dim edits = GetTopEdits(src1, src2)
 
             edits.VerifyEdits(
-                "Update [Module C]@0 -> [Partial Module C]@0")
+                "Update [" & keyword & " C]@0 -> [Partial " & keyword & " C]@0")
 
             edits.VerifyRudeDiagnostics()
         End Sub
 
         <Fact>
-        Public Sub ModuleModifiersUpdate2()
+        Public Sub Module_PartialModifier_Remove()
             Dim src1 = "Partial Module C : End Module"
             Dim src2 = "Module C : End Module"
             Dim edits = GetTopEdits(src1, src2)
@@ -596,53 +605,73 @@ Option Strict Off
         End Sub
 
         <Fact>
-        Public Sub InterfaceModifiersUpdate()
-            Dim src1 = "Public Interface C : End Interface"
-            Dim src2 = "Interface C : End Interface"
+        Public Sub ClassInsert()
+            Dim src1 = ""
+            Dim src2 = "Class C : End Class"
             Dim edits = GetTopEdits(src1, src2)
 
-            edits.VerifyEdits(
-                "Update [Public Interface C]@0 -> [Interface C]@0")
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Interface C", FeaturesResources.interface_))
+            edits.VerifyRudeDiagnostics()
         End Sub
 
         <Fact>
-        Public Sub InterfaceModifiersUpdate2()
-            Dim src1 = "Public Interface C : Sub Goo() : End Interface"
-            Dim src2 = "Interface C : Sub Goo() : End Interface"
+        Public Sub StructInsert()
+            Dim src1 = ""
+            Dim src2 = "Structure C : End Structure"
             Dim edits = GetTopEdits(src1, src2)
 
-            edits.VerifyEdits(
-                "Update [Public Interface C]@0 -> [Interface C]@0")
+            edits.VerifyRudeDiagnostics()
+        End Sub
 
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Interface C", FeaturesResources.interface_))
+        <Fact>
+        Public Sub PartialInterfaceInsert()
+            Dim src1 = ""
+            Dim src2 = "Partial Interface C : End Interface"
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifySemantics(semanticEdits:=
+            {
+                SemanticEdit(SemanticEditKind.Insert, Function(c) c.GetMember("C"))
+            })
         End Sub
 
         <Fact>
-        Public Sub InterfaceModifiersUpdate3()
-            Dim src1 = "Interface C : Sub Goo() : End Interface"
-            Dim src2 = "Partial Interface C : Sub Goo() : End Interface"
+        Public Sub PartialInterfaceDelete()
+            Dim src1 = "Partial Interface C : End Interface"
+            Dim src2 = ""
             Dim edits = GetTopEdits(src1, src2)
 
-            edits.VerifyEdits(
-                "Update [Interface C]@0 -> [Partial Interface C]@0")
+            edits.VerifySemanticDiagnostics(
+                Diagnostic(RudeEditKind.Delete, Nothing, DeletedSymbolDisplay(FeaturesResources.interface_, "C")))
+        End Sub
 
-            edits.VerifyRudeDiagnostics()
+        <Fact>
+        Public Sub ModuleInsert()
+            Dim src1 = ""
+            Dim src2 = "Module C : End Module"
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.Insert, "Module C", VBFeaturesResources.module_))
         End Sub
 
         <Fact>
-        Public Sub StructModifiersUpdate()
-            Dim src1 = "Structure C : End Structure"
-            Dim src2 = "Public Structure C : End Structure"
+        Public Sub PartialModuleInsert()
+            Dim src1 = ""
+            Dim src2 = "Partial Module C : End Module"
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.Insert, "Partial Module C", VBFeaturesResources.module_))
+        End Sub
 
+        <Fact>
+        Public Sub PartialModuleDelete()
+            Dim src1 = "Partial Module C : End Module"
+            Dim src2 = ""
             Dim edits = GetTopEdits(src1, src2)
-            edits.VerifyEdits("Update [Structure C]@0 -> [Public Structure C]@0")
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Public Structure C", VBFeaturesResources.structure_))
+                Diagnostic(RudeEditKind.Delete, Nothing, DeletedSymbolDisplay(VBFeaturesResources.module_, "C")))
         End Sub
 
         <Fact>
@@ -872,7 +901,11 @@ End Interface
                 {GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2)},
                 {
                     DocumentResults(),
-                    DocumentResults()
+                    DocumentResults(semanticEdits:=
+                    {
+                        SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember("I.VirtualMethod")),
+                        SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember("I.VirtualFunction"))
+                    })
                 })
         End Sub
 
@@ -1102,7 +1135,8 @@ Delegate Sub D()
                         {
                             SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("C").GetMember("F")),
                             SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("M").GetMember("F")),
-                            SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("S").GetMember("F"))
+                            SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("S").GetMember("F")),
+                            SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("I").GetMember("F"))
                         })
                 })
         End Sub
@@ -1177,9 +1211,11 @@ End Interface
                     DocumentResults(
                         semanticEdits:=
                         {
+                            SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("C").GetMember("AbstractMethod")),
                             SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("C").GetMember("VirtualMethod")),
                             SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("C").GetMember("ToString")),
-                            SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("C").GetMember("IG"))
+                            SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("C").GetMember("IG")),
+                            SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("I").GetMember("G"))
                         })
                 })
         End Sub
@@ -1313,7 +1349,7 @@ End Class
         End Sub
 
         <Fact>
-        Public Sub Enum_Modifiers_Update()
+        Public Sub Enum_Accessibility_Change()
             Dim src1 = "Public Enum Color : Red = 1 : Blue = 2 : End Enum"
             Dim src2 = "Enum Color : Red = 1 : Blue = 2 : End Enum"
             Dim edits = GetTopEdits(src1, src2)
@@ -1322,7 +1358,19 @@ End Class
                 "Update [Public Enum Color]@0 -> [Enum Color]@0")
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Enum Color", FeaturesResources.enum_))
+                Diagnostic(RudeEditKind.ChangingAccessibility, "Enum Color", FeaturesResources.enum_))
+        End Sub
+
+        <Fact>
+        Public Sub Enum_Accessibility_NoChange()
+            Dim src1 = "Friend Enum Color : Red = 1 : Blue = 2 : End Enum"
+            Dim src2 = "Enum Color : Red = 1 : Blue = 2 : End Enum"
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyEdits(
+                "Update [Friend Enum Color]@0 -> [Enum Color]@0")
+
+            edits.VerifySemantics()
         End Sub
 
         <Fact>
@@ -1581,7 +1629,7 @@ End Class
         End Sub
 
         <Fact>
-        Public Sub Delegates_Update_Modifiers()
+        Public Sub Delegates_Accessibility_Update()
             Dim src1 = "Public Delegate Sub D()"
             Dim src2 = "Private Delegate Sub D()"
             Dim edits = GetTopEdits(src1, src2)
@@ -1590,7 +1638,7 @@ End Class
                 "Update [Public Delegate Sub D()]@0 -> [Private Delegate Sub D()]@0")
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Private Delegate Sub D()", FeaturesResources.delegate_))
+                Diagnostic(RudeEditKind.ChangingAccessibility, "Private Delegate Sub D()", FeaturesResources.delegate_))
         End Sub
 
         <Fact>
@@ -2969,6 +3017,98 @@ End Class"
 #End Region
 
 #Region "Methods"
+        <Theory>
+        <InlineData("Shared")>
+        <InlineData("Overridable")>
+        <InlineData("Overrides")>
+        <InlineData("NotOverridable Overrides", "Overrides")>
+        Public Sub Method_Modifiers_Update(oldModifiers As String, Optional newModifiers As String = "")
+            If oldModifiers <> "" Then
+                oldModifiers &= " "
+            End If
+
+            If newModifiers <> "" Then
+                newModifiers &= " "
+            End If
+
+            Dim src1 = "Class C" & vbCrLf & oldModifiers & "Sub F() : End Sub : End Class"
+            Dim src2 = "Class C" & vbCrLf & newModifiers & "Sub F() : End Sub : End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyEdits(
+                "Update [" & oldModifiers & "Sub F() : End Sub]@9 -> [" & newModifiers & "Sub F() : End Sub]@9",
+                "Update [" & oldModifiers & "Sub F()]@9 -> [" & newModifiers & "Sub F()]@9")
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, newModifiers + "Sub F()", FeaturesResources.method))
+        End Sub
+
+        <Fact>
+        Public Sub Method_MustOverrideModifier_Update()
+            Dim src1 = "Class C" & vbCrLf & "MustOverride Sub F() : End Class"
+            Dim src2 = "Class C" & vbCrLf & "Sub F() : End Sub : End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "Sub F()", FeaturesResources.method))
+        End Sub
+
+        <Theory>
+        <InlineData("Shadows")>
+        <InlineData("Overloads")>
+        Public Sub Method_Modifiers_Update_NoImpact(oldModifiers As String, Optional newModifiers As String = "")
+            If oldModifiers <> "" Then
+                oldModifiers &= " "
+            End If
+
+            If newModifiers <> "" Then
+                newModifiers &= " "
+            End If
+
+            Dim src1 = "Class C " & vbLf & oldModifiers & "Sub F() : End Sub : End Class"
+            Dim src2 = "Class C " & vbLf & newModifiers & "Sub F() : End Sub : End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyEdits(
+                "Update [" & oldModifiers & "Sub F() : End Sub]@9 -> [" & newModifiers & "Sub F() : End Sub]@9",
+                "Update [" & oldModifiers & "Sub F()]@9 -> [" & newModifiers & "Sub F()]@9")
+
+            ' Currently, an edit is produced eventhough there is no metadata/IL change. Consider improving.
+            edits.VerifySemantics(
+                semanticEdits:={SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("C").GetMember(Of MethodSymbol)("F"))})
+        End Sub
+
+        <Fact>
+        Public Sub Method_AsyncModifier_Add()
+            Dim src1 = "Class C : " & vbLf & "Function F() As Task(Of String) : End Function : End Class"
+            Dim src2 = "Class C : " & vbLf & "Async Function F() As Task(Of String) : End Function : End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyEdits(
+                "Update [Function F() As Task(Of String) : End Function]@11 -> [Async Function F() As Task(Of String) : End Function]@11",
+                "Update [Function F() As Task(Of String)]@11 -> [Async Function F() As Task(Of String)]@11")
+
+            edits.VerifyRudeDiagnostics()
+        End Sub
+
+        <Fact>
+        Public Sub Method_AsyncModifier_Remove()
+            Dim src1 = "Class C : " & vbLf & "Async Function F() As Task(Of String) : End Function : End Class"
+            Dim src2 = "Class C : " & vbLf & "Function F() As Task(Of String) : End Function : End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyEdits(
+                "Update [Async Function F() As Task(Of String) : End Function]@11 -> [Function F() As Task(Of String) : End Function]@11",
+                "Update [Async Function F() As Task(Of String)]@11 -> [Function F() As Task(Of String)]@11")
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingFromAsynchronousToSynchronous, "Function F()", FeaturesResources.method))
+        End Sub
 
         <Fact>
         Public Sub MethodUpdate1()
@@ -3316,35 +3456,6 @@ Imports System.Runtime.InteropServices
                 Diagnostic(RudeEditKind.Renamed, "Sub Bar", FeaturesResources.method))
         End Sub
 
-        <Fact>
-        Public Sub MethodUpdate_AsyncModifier1()
-            Dim src1 = "Class C : " & vbLf & "Function F() As Task(Of String) : End Function : End Class"
-            Dim src2 = "Class C : " & vbLf & "Async Function F() As Task(Of String) : End Function : End Class"
-
-            Dim edits = GetTopEdits(src1, src2)
-
-            edits.VerifyEdits(
-                "Update [Function F() As Task(Of String) : End Function]@11 -> [Async Function F() As Task(Of String) : End Function]@11",
-                "Update [Function F() As Task(Of String)]@11 -> [Async Function F() As Task(Of String)]@11")
-
-            edits.VerifyRudeDiagnostics()
-        End Sub
-
-        <Fact>
-        Public Sub MethodUpdate_AsyncModifier2()
-            Dim src1 = "Class C : " & vbLf & "Async Function F() As Task(Of String) : End Function : End Class"
-            Dim src2 = "Class C : " & vbLf & "Function F() As Task(Of String) : End Function : End Class"
-
-            Dim edits = GetTopEdits(src1, src2)
-
-            edits.VerifyEdits(
-                "Update [Async Function F() As Task(Of String) : End Function]@11 -> [Function F() As Task(Of String) : End Function]@11",
-                "Update [Async Function F() As Task(Of String)]@11 -> [Function F() As Task(Of String)]@11")
-
-            edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ChangingFromAsynchronousToSynchronous, "Function F()", FeaturesResources.method))
-        End Sub
-
         <Fact>
         Public Sub MethodUpdate_IteratorModifier1()
             Dim src1 = "Class C : " & vbLf & "Function F() As Task(Of String) : End Function : End Class"
@@ -3943,19 +4054,14 @@ End Class
             Dim srcA2 = "Partial Class C" + vbCrLf + "Private Sub F() : End Sub : End Class"
             Dim srcB2 = "Partial Class C" + vbCrLf + "Partial Private Sub F() : End Sub : End Class"
 
-            ' TODO: current
-            GetTopEdits(srcA1, srcA2).VerifyRudeDiagnostics(Diagnostic(RudeEditKind.ModifiersUpdate, "Private Sub F()", FeaturesResources.method))
-            GetTopEdits(srcB1, srcB2).VerifyRudeDiagnostics(Diagnostic(RudeEditKind.ModifiersUpdate, "Partial Private Sub F()", FeaturesResources.method))
-
-            ' TODO: correct 
-            ' EditAndContinueValidation.VerifySemantics(
-            '      { GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2) },
-            '     
-            '     {
-            '         DocumentResults(),
-            '         DocumentResults(
-            '             semanticEdits:= { SemanticEdit(SemanticEditKind.Update, c => c.GetMember(Of NamedTypeSymbol)("C").GetMember("F")) }),
-            '     });
+            ' TODO: should be an update edit since the location of the implementation changed
+            ' semanticEdits:={SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember(Of NamedTypeSymbol)("C").GetMember("F"))}
+            EditAndContinueValidation.VerifySemantics(
+                {GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2)},
+                {
+                    DocumentResults(),
+                    DocumentResults()
+                })
         End Sub
 
         <Fact>
@@ -4035,6 +4141,21 @@ End Class
 
 #Region "Operators"
 
+        <Theory>
+        <InlineData("Narrowing", "Widening")>
+        <InlineData("Widening", "Narrowing")>
+        Public Sub Operator_Modifiers_Update(oldModifiers As String, newModifiers As String)
+            Dim src1 = "Class C" & vbCrLf & "Public Shared " & oldModifiers & " Operator CType(d As C) As Integer : End Operator : End Class"
+            Dim src2 = "Class C" & vbCrLf & "Public Shared " & newModifiers & " Operator CType(d As C) As Integer : End Operator : End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyEdits("Update [Public Shared " + oldModifiers + " Operator CType(d As C) As Integer]@9 -> [Public Shared " + newModifiers + " Operator CType(d As C) As Integer]@9")
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "Public Shared " & newModifiers & " Operator CType(d As C)", FeaturesResources.operator_))
+        End Sub
+
         <Fact>
         Public Sub OperatorInsert()
             Dim src1 = "
@@ -4299,7 +4420,7 @@ End Class
             Dim edits = GetTopEdits(src1, src2)
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "Class C", DeletedSymbolDisplay(FeaturesResources.constructor, "New()")))
+                Diagnostic(RudeEditKind.ChangingAccessibility, "Class C", DeletedSymbolDisplay(FeaturesResources.constructor, "New()")))
         End Sub
 
         <Fact>
@@ -4411,7 +4532,7 @@ End Class
             Dim edits = GetTopEdits(src1, src2)
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, visibility & " Sub New()", FeaturesResources.constructor))
+                Diagnostic(RudeEditKind.ChangingAccessibility, visibility & " Sub New()", FeaturesResources.constructor))
         End Sub
 
         <Fact>
@@ -4535,7 +4656,7 @@ End Class
                 {
                     DocumentResults(),
                     DocumentResults(
-                        diagnostics:={Diagnostic(RudeEditKind.ModifiersUpdate, "Public Sub New()", FeaturesResources.constructor)})
+                        diagnostics:={Diagnostic(RudeEditKind.ChangingAccessibility, "Public Sub New()", FeaturesResources.constructor)})
                 })
         End Sub
 
@@ -4656,7 +4777,7 @@ End Class
         <InlineData("")>
         <InlineData("Friend")>
         <InlineData("Public")>
-        Public Sub InstanceCtor_Partial_VisibilityUpdate(visibility As String)
+        Public Sub InstanceCtor_Partial_AccessibilityUpdate(visibility As String)
             If visibility.Length > 0 Then
                 visibility &= " "
             End If
@@ -4672,7 +4793,7 @@ End Class
                 {GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2)},
                 {
                     DocumentResults(
-                        diagnostics:={Diagnostic(RudeEditKind.ModifiersUpdate, visibility & "Sub New()", FeaturesResources.constructor)}),
+                        diagnostics:={Diagnostic(RudeEditKind.ChangingAccessibility, visibility & "Sub New()", FeaturesResources.constructor)}),
                     DocumentResults()
                 })
         End Sub
@@ -5318,12 +5439,35 @@ End Class
                 {GetTopEdits(srcA1, srcA2), GetTopEdits(srcB1, srcB2)},
                 {
                     DocumentResults(),
-                    DocumentResults()
+                    DocumentResults(semanticEdits:={SemanticEdit(SemanticEditKind.Update, Function(c) c.GetMember("M.ExternSub"))})
                 })
         End Sub
 #End Region
 
 #Region "Fields"
+        <Theory>
+        <InlineData("Shared")>
+        <InlineData("Const")>
+        Public Sub Field_Modifiers_Update(oldModifiers As String, Optional newModifiers As String = "")
+            If oldModifiers <> "" Then
+                oldModifiers &= " "
+            End If
+
+            If newModifiers <> "" Then
+                newModifiers &= " "
+            End If
+
+            Dim src1 = "Class C : " & oldModifiers & "Dim F As Integer = 0 : End Class"
+            Dim src2 = "Class C : " & newModifiers & "Dim F As Integer = 0 : End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyEdits("Update [" & oldModifiers & "Dim F As Integer = 0]@10 -> [" & newModifiers & "Dim F As Integer = 0]@10")
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, newModifiers + "F As Integer = 0", FeaturesResources.field))
+        End Sub
+
         <Fact>
         Public Sub FieldUpdate_Rename1()
             Dim src1 = "Class C : Dim a As Integer = 0 : End Class"
@@ -5633,7 +5777,7 @@ End Class
                 "Update [Dim a As WE]@10 -> [WithEvents a As WE]@10")
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "WithEvents a As WE", VBFeaturesResources.WithEvents_field))
+                Diagnostic(RudeEditKind.ModifiersUpdate, "a As WE", VBFeaturesResources.WithEvents_field))
         End Sub
 
         <Fact>
@@ -5646,7 +5790,7 @@ End Class
                 "Update [WithEvents a As WE]@10 -> [Dim a As WE]@10")
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Dim a As WE", FeaturesResources.field))
+                Diagnostic(RudeEditKind.ModifiersUpdate, "a As WE", FeaturesResources.field))
         End Sub
 
         <Fact>
@@ -6120,6 +6264,42 @@ End Class
 #End Region
 
 #Region "Properties"
+        <Theory>
+        <InlineData("Shared")>
+        <InlineData("Overridable")>
+        <InlineData("Overrides")>
+        <InlineData("NotOverridable Overrides", "Overrides")>
+        Public Sub Property_Modifiers_Update(oldModifiers As String, Optional newModifiers As String = "")
+            If oldModifiers <> "" Then
+                oldModifiers &= " "
+            End If
+
+            If newModifiers <> "" Then
+                newModifiers &= " "
+            End If
+
+            Dim src1 = "Class C" & vbLf & oldModifiers & "ReadOnly Property F As Integer" & vbLf & "Get" & vbLf & "Return 1 : End Get : End Property : End Class"
+            Dim src2 = "Class C" & vbLf & newModifiers & "ReadOnly Property F As Integer" & vbLf & "Get" & vbLf & "Return 1 : End Get : End Property : End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyEdits("Update [" & oldModifiers & "ReadOnly Property F As Integer]@8 -> [" & newModifiers & "ReadOnly Property F As Integer]@8")
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, newModifiers + "ReadOnly Property F", FeaturesResources.property_))
+        End Sub
+
+        <Fact>
+        Public Sub Property_MustOverrideModifier_Update()
+            Dim src1 = "Class C" & vbLf & "ReadOnly MustOverride Property F As Integer" & vbLf & "End Class"
+            Dim src2 = "Class C" & vbLf & "ReadOnly Property F As Integer" & vbLf & "Get" & vbLf & "Return 1 : End Get : End Property : End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, "ReadOnly Property F", FeaturesResources.property_))
+        End Sub
+
         <Fact>
         Public Sub PropertyReorder1()
             Dim src1 = "Class C : ReadOnly Property P" & vbLf & "Get" & vbLf & "Return 1 : End Get : End Property : " &
@@ -6780,7 +6960,7 @@ End Class
             Dim edits = GetTopEdits(src1, src2)
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "Class C", DeletedSymbolDisplay(FeaturesResources.constructor, "New()")))
+                Diagnostic(RudeEditKind.ChangingAccessibility, "Class C", DeletedSymbolDisplay(FeaturesResources.constructor, "New()")))
         End Sub
 
         <Fact>
@@ -6790,7 +6970,7 @@ End Class
             Dim edits = GetTopEdits(src1, src2)
 
             edits.VerifySemanticDiagnostics(
-                Diagnostic(RudeEditKind.ChangingVisibility, "Class C", DeletedSymbolDisplay(FeaturesResources.constructor, "New()")))
+                Diagnostic(RudeEditKind.ChangingAccessibility, "Class C", DeletedSymbolDisplay(FeaturesResources.constructor, "New()")))
         End Sub
 
         <Fact>
@@ -7563,7 +7743,7 @@ End Class
             Dim edits = GetTopEdits(src1, src2)
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Dim x = 0", FeaturesResources.field))
+                Diagnostic(RudeEditKind.ModifiersUpdate, "x = 0", FeaturesResources.field))
         End Sub
 
         <Fact>
@@ -7573,7 +7753,7 @@ End Class
             Dim edits = GetTopEdits(src1, src2)
 
             edits.VerifyRudeDiagnostics(
-                Diagnostic(RudeEditKind.ModifiersUpdate, "Const x = 0", FeaturesResources.const_field))
+                Diagnostic(RudeEditKind.ModifiersUpdate, "x = 0", FeaturesResources.const_field))
         End Sub
 
         <Fact>
@@ -8317,6 +8497,47 @@ End Class
 
 #Region "Events"
 
+        <Theory>
+        <InlineData("Shared")>
+        Public Sub Event_Modifiers_Update(oldModifiers As String, Optional newModifiers As String = "")
+            If oldModifiers <> "" Then
+                oldModifiers &= " "
+            End If
+
+            If newModifiers <> "" Then
+                newModifiers &= " "
+            End If
+
+            Dim src1 = "
+Class C
+   " & oldModifiers & " Custom Event E As Action
+    AddHandler(value As Action)
+    End AddHandler
+    RemoveHandler(value As Action)
+    End RemoveHandler
+    RaiseEvent()
+    End RaiseEvent
+  End Event
+End Class"
+
+            Dim src2 = "
+Class C
+   " & newModifiers & " Custom Event E As Action
+    AddHandler(value As Action)
+    End AddHandler
+    RemoveHandler(value As Action)
+    End RemoveHandler
+    RaiseEvent()
+    End RaiseEvent
+  End Event
+End Class"
+
+            Dim edits = GetTopEdits(src1, src2)
+
+            edits.VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ModifiersUpdate, newModifiers + "Event E", FeaturesResources.event_))
+        End Sub
+
         <Fact>
         Public Sub EventAccessorReorder1()
             Dim src1 = "Class C : " &
diff --git a/src/EditorFeatures/VisualBasicTest/InlineMethod/VisualBasicInlineMethodTests.vb b/src/EditorFeatures/VisualBasicTest/InlineMethod/VisualBasicInlineMethodTests.vb
index 8319399c77f65..035d4cdb4b5a6 100644
--- a/src/EditorFeatures/VisualBasicTest/InlineMethod/VisualBasicInlineMethodTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/InlineMethod/VisualBasicInlineMethodTests.vb
@@ -33,6 +33,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.InlineMethod
                 If diagnosticResults IsNot Nothing Then
                     test.FixedState.ExpectedDiagnostics.AddRange(diagnosticResults)
                 End If
+
                 Await test.RunAsync().ConfigureAwait(False)
             End Function
 
@@ -47,6 +48,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.InlineMethod
                 If diagnnoticResults IsNot Nothing Then
                     test.FixedState.ExpectedDiagnostics.AddRange(diagnnoticResults)
                 End If
+
                 Await test.RunAsync().ConfigureAwait(False)
             End Function
 
diff --git a/src/EditorFeatures/VisualBasicTest/InvertIf/InvertMultiLineIfTests.vb b/src/EditorFeatures/VisualBasicTest/InvertIf/InvertMultiLineIfTests.vb
index 51d45e8433979..49615cd184a06 100644
--- a/src/EditorFeatures/VisualBasicTest/InvertIf/InvertMultiLineIfTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/InvertIf/InvertMultiLineIfTests.vb
@@ -654,5 +654,60 @@ Imports System
 
             Await TestAsync(markup, expected)
         End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInvertIf)>
+        Public Async Function InvertIfWithoutStatements() As Task
+            Await TestInRegularAndScriptAsync(
+"class C
+    sub M(x as String)
+        [||]If x = ""a"" Then
+        Else
+            DoSomething()
+        End If
+    end sub
+
+    sub DoSomething()
+    end sub
+end class",
+"class C
+    sub M(x as String)
+        If x IsNot ""a"" Then
+            DoSomething()
+        End If
+    end sub
+
+    sub DoSomething()
+    end sub
+end class")
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInvertIf)>
+        Public Async Function InvertIfWithOnlyComment() As Task
+            Await TestInRegularAndScriptAsync(
+"class C
+    sub M(x as String)
+        [||]If x = ""a"" Then
+            ' A comment in a blank if statement
+        Else
+            DoSomething()
+        End If
+    end sub
+
+    sub DoSomething()
+    end sub
+end class",
+"class C
+    sub M(x as String)
+        If x IsNot ""a"" Then
+            DoSomething()
+        Else
+            ' A comment in a blank if statement
+        End If
+    end sub
+
+    sub DoSomething()
+    end sub
+end class")
+        End Function
     End Class
 End Namespace
diff --git a/src/EditorFeatures/VisualBasicTest/NavigateTo/NavigateToTests.vb b/src/EditorFeatures/VisualBasicTest/NavigateTo/NavigateToTests.vb
index 5a85a01c060e6..820341176ecdc 100644
--- a/src/EditorFeatures/VisualBasicTest/NavigateTo/NavigateToTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/NavigateTo/NavigateToTests.vb
@@ -708,6 +708,17 @@ End Class", Async Function(w)
             End Function)
         End Function
 
+        <Theory>
+        <CombinatorialData>
+        Public Async Function TestFindAbstractMethod(testHost As TestHost, composition As Composition) As Task
+            Await TestAsync(testHost, composition, "MustInherit Class A
+Public MustOverride Sub M()
+End Class", Async Function(w)
+                Dim item = (Await _aggregator.GetItemsAsync("M")).Single
+                VerifyNavigateToResultItem(item, "M", "[|M|]()", PatternMatchKind.Exact, NavigateToItemKind.Method, Glyph.MethodPublic, additionalInfo:=String.Format(FeaturesResources.in_0_project_1, "A", "Test"))
+            End Function)
+        End Function
+
         <WorkItem(1111131, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1111131")>
         <Theory>
         <CombinatorialData>
diff --git a/src/EditorFeatures/VisualBasicTest/SymbolId/SymbolKeyTestBase.vb b/src/EditorFeatures/VisualBasicTest/SymbolId/SymbolKeyTestBase.vb
index 417b098991897..e799f67663a49 100644
--- a/src/EditorFeatures/VisualBasicTest/SymbolId/SymbolKeyTestBase.vb
+++ b/src/EditorFeatures/VisualBasicTest/SymbolId/SymbolKeyTestBase.vb
@@ -118,6 +118,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.SymbolId
                     Exit For
                 End Try
             Next
+
             Return list
         End Function
 
@@ -206,6 +207,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.SymbolId
                         For Each parameter In method.Parameters
                             list.Add(parameter)
                         Next
+
                         If localDumper IsNot Nothing Then
                             localDumper.GetLocalSymbols(method, list)
                         End If
diff --git a/src/EditorFeatures/VisualBasicTest/Utils.vb b/src/EditorFeatures/VisualBasicTest/Utils.vb
index bff5d95709557..fecfbf870587f 100644
--- a/src/EditorFeatures/VisualBasicTest/Utils.vb
+++ b/src/EditorFeatures/VisualBasicTest/Utils.vb
@@ -54,6 +54,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests
             If TypeOf (node) Is T Then
                 Return CType(node, T)
             End If
+
             For Each child In node.ChildNodesAndTokens()
                 If child.IsNode Then
                     Dim foundNode = child.AsNode().FindFirstNodeOfType(Of T)()
@@ -62,6 +63,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests
                     End If
                 End If
             Next
+
             Return Nothing
         End Function
 
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs
index 88646841d168f..69fa80e320486 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs
@@ -363,5 +363,10 @@ internal static void VerifyTypeParameters(Symbol container, ImmutableArray<TypeP
                 Debug.Assert(typeParameter.Ordinal == i);
             }
         }
+
+        internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+        {
+            return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+        }
     }
 }
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/SimpleTypeParameterSymbol.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/SimpleTypeParameterSymbol.cs
index de45ef9551757..604bfbce2c7b8 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/SimpleTypeParameterSymbol.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/SimpleTypeParameterSymbol.cs
@@ -8,6 +8,7 @@
 using Roslyn.Utilities;
 using System;
 using System.Collections.Immutable;
+using System.Diagnostics;
 
 namespace Microsoft.CodeAnalysis.CSharp.ExpressionEvaluator
 {
@@ -25,6 +26,11 @@ public SimpleTypeParameterSymbol(Symbol container, int ordinal, string name)
             _container = container;
             _ordinal = ordinal;
             _name = name;
+
+            Debug.Assert(this.TypeParameterKind == (ContainingSymbol is MethodSymbol ? TypeParameterKind.Method :
+                                                   (ContainingSymbol is NamedTypeSymbol ? TypeParameterKind.Type :
+                                                   TypeParameterKind.Cref)),
+                         $"Container is {ContainingSymbol?.Kind}, TypeParameterKind is {this.TypeParameterKind}");
         }
 
         public override string Name
@@ -39,7 +45,7 @@ public override int Ordinal
 
         public override TypeParameterKind TypeParameterKind
         {
-            get { return TypeParameterKind.Type; }
+            get { return ContainingSymbol is MethodSymbol ? TypeParameterKind.Method : TypeParameterKind.Type; }
         }
 
         public override bool HasConstructorConstraint
diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Symbols/SimpleTypeParameterSymbol.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Symbols/SimpleTypeParameterSymbol.vb
index 6ac0b20075f3a..19b822a4c7a74 100644
--- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Symbols/SimpleTypeParameterSymbol.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Symbols/SimpleTypeParameterSymbol.vb
@@ -21,6 +21,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
             _container = container
             _ordinal = ordinal
             _name = name
+
+            Debug.Assert(Me.TypeParameterKind = If(TypeOf Me.ContainingSymbol Is MethodSymbol, TypeParameterKind.Method,
+                                                If(TypeOf Me.ContainingSymbol Is NamedTypeSymbol, TypeParameterKind.Type,
+                                                TypeParameterKind.Cref)),
+                $"Container is {Me.ContainingSymbol?.Kind}, TypeParameterKind is {Me.TypeParameterKind}")
         End Sub
 
         Public Overrides ReadOnly Property Name As String
@@ -37,7 +42,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
 
         Public Overrides ReadOnly Property TypeParameterKind As TypeParameterKind
             Get
-                Return TypeParameterKind.Type
+                Return If(TypeOf Me.ContainingSymbol Is MethodSymbol, TypeParameterKind.Method, TypeParameterKind.Type)
             End Get
         End Property
 
diff --git a/src/Features/CSharp/Portable/AddImport/CSharpAddImportFeatureService.cs b/src/Features/CSharp/Portable/AddImport/CSharpAddImportFeatureService.cs
index 98aa8476b33a0..a79df5f04de87 100644
--- a/src/Features/CSharp/Portable/AddImport/CSharpAddImportFeatureService.cs
+++ b/src/Features/CSharp/Portable/AddImport/CSharpAddImportFeatureService.cs
@@ -79,6 +79,7 @@ protected override bool CanAddImportForMethod(
                     {
                         node = memberBindingExpr.Name;
                     }
+
                     break;
                 case CS1929:
                     var memberAccessName = (node.Parent as MemberAccessExpressionSyntax)?.Name;
diff --git a/src/Features/CSharp/Portable/CodeFixes/Nullable/CSharpDeclareAsNullableCodeFixProvider.cs b/src/Features/CSharp/Portable/CodeFixes/Nullable/CSharpDeclareAsNullableCodeFixProvider.cs
index a0ec4c5eccddd..4c6e11dcb4707 100644
--- a/src/Features/CSharp/Portable/CodeFixes/Nullable/CSharpDeclareAsNullableCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/CodeFixes/Nullable/CSharpDeclareAsNullableCodeFixProvider.cs
@@ -349,8 +349,10 @@ declarator.Parent is VariableDeclarationSyntax declaration &&
                         {
                             return typeArguments[0];
                         }
+
                         break;
                 }
+
                 return null;
             }
 
@@ -363,6 +365,7 @@ parameterSymbol.ContainingSymbol is IMethodSymbol method &&
                 {
                     return parameterSyntax.Type;
                 }
+
                 return null;
             }
         }
diff --git a/src/Features/CSharp/Portable/CodeLens/CSharpCodeLensDisplayInfoService.cs b/src/Features/CSharp/Portable/CodeLens/CSharpCodeLensDisplayInfoService.cs
index aca40f15c355a..3eca553c17f7a 100644
--- a/src/Features/CSharp/Portable/CodeLens/CSharpCodeLensDisplayInfoService.cs
+++ b/src/Features/CSharp/Portable/CodeLens/CSharpCodeLensDisplayInfoService.cs
@@ -68,6 +68,7 @@ public SyntaxNode GetDisplayNode(SyntaxNode node)
                             node = structuredTriviaSyntax.ParentTrivia.Token.Parent;
                             continue;
                         }
+
                         return null;
 
                     default:
diff --git a/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.cs
index 1d1d5bed174a8..b76a2dce544b5 100644
--- a/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.cs
@@ -155,6 +155,7 @@ private static bool CanSimplify(
                 // Don't offer this if there are any errors or ambiguities.
                 return false;
             }
+
             if (!(lambdaSemanticInfo.Symbol is IMethodSymbol lambdaMethod) || !(invocationSemanticInfo.Symbol is IMethodSymbol invocationMethod))
             {
                 return false;
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/AttributeNamedParameterCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/AttributeNamedParameterCompletionProvider.cs
index db95740e9ce31..b08aae477befe 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/AttributeNamedParameterCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/AttributeNamedParameterCompletionProvider.cs
@@ -69,6 +69,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
                 {
                     return;
                 }
+
                 if (token.Parent.Parent is not AttributeSyntax attributeSyntax || token.Parent is not AttributeArgumentListSyntax attributeArgumentList)
                 {
                     return;
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.NameGenerator.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.NameGenerator.cs
index b15a95ab04146..d3bf4298ccfc1 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.NameGenerator.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.NameGenerator.cs
@@ -106,6 +106,7 @@ private static string TryRemoveInterfacePrefix(ITypeSymbol type)
                         return name.Substring(1);
                     }
                 }
+
                 return type.CreateParameterName();
             }
         }
diff --git a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/AbstractKeywordRecommender.cs b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/AbstractKeywordRecommender.cs
index a062416c33896..4c4cfb7d823b8 100644
--- a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/AbstractKeywordRecommender.cs
+++ b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/AbstractKeywordRecommender.cs
@@ -13,7 +13,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Completion.KeywordRecommenders
 {
     internal class AbstractKeywordRecommender : AbstractSyntacticSingleKeywordRecommender
     {
-        private static readonly ISet<SyntaxKind> s_validMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        private static readonly ISet<SyntaxKind> s_validNonInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
         {
             SyntaxKind.ExternKeyword,
             SyntaxKind.InternalKeyword,
@@ -24,6 +24,18 @@ internal class AbstractKeywordRecommender : AbstractSyntacticSingleKeywordRecomm
             SyntaxKind.OverrideKeyword,
         };
 
+        private static readonly ISet<SyntaxKind> s_validInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        {
+            SyntaxKind.ExternKeyword,
+            SyntaxKind.InternalKeyword,
+            SyntaxKind.NewKeyword,
+            SyntaxKind.PublicKeyword,
+            SyntaxKind.ProtectedKeyword,
+            SyntaxKind.StaticKeyword,
+            SyntaxKind.UnsafeKeyword,
+            SyntaxKind.OverrideKeyword,
+        };
+
         private static readonly ISet<SyntaxKind> s_validTypeModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
             {
                 SyntaxKind.InternalKeyword,
@@ -44,8 +56,13 @@ protected override bool IsValidContext(int position, CSharpSyntaxContext context
             return
                 context.IsGlobalStatementContext ||
                 context.IsMemberDeclarationContext(
-                    validModifiers: s_validMemberModifiers,
-                    validTypeDeclarations: SyntaxKindSet.ClassInterfaceRecordTypeDeclarations,
+                    validModifiers: s_validNonInterfaceMemberModifiers,
+                    validTypeDeclarations: SyntaxKindSet.ClassRecordTypeDeclarations,
+                    canBePartial: false,
+                    cancellationToken: cancellationToken) ||
+                context.IsMemberDeclarationContext(
+                    validModifiers: s_validInterfaceMemberModifiers,
+                    validTypeDeclarations: SyntaxKindSet.InterfaceOnlyTypeDeclarations,
                     canBePartial: false,
                     cancellationToken: cancellationToken) ||
                 context.IsTypeDeclarationContext(
diff --git a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ExplicitKeywordRecommender.cs b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ExplicitKeywordRecommender.cs
index c6ed3cd79e1f0..b7198e35ba18d 100644
--- a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ExplicitKeywordRecommender.cs
+++ b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ExplicitKeywordRecommender.cs
@@ -13,7 +13,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Completion.KeywordRecommenders
 {
     internal class ExplicitKeywordRecommender : AbstractSyntacticSingleKeywordRecommender
     {
-        private static readonly ISet<SyntaxKind> s_validMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        private static readonly ISet<SyntaxKind> s_validNonInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
             {
                 SyntaxKind.StaticKeyword,
                 SyntaxKind.PublicKeyword,
@@ -21,6 +21,14 @@ internal class ExplicitKeywordRecommender : AbstractSyntacticSingleKeywordRecomm
                 SyntaxKind.UnsafeKeyword,
             };
 
+        private static readonly ISet<SyntaxKind> s_validInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+            {
+                SyntaxKind.StaticKeyword,
+                SyntaxKind.PublicKeyword,
+                SyntaxKind.AbstractKeyword,
+                SyntaxKind.UnsafeKeyword,
+            };
+
         public ExplicitKeywordRecommender()
             : base(SyntaxKind.ExplicitKeyword)
         {
@@ -28,7 +36,7 @@ public ExplicitKeywordRecommender()
 
         protected override bool IsValidContext(int position, CSharpSyntaxContext context, CancellationToken cancellationToken)
         {
-            if (context.IsMemberDeclarationContext(validModifiers: s_validMemberModifiers, validTypeDeclarations: SyntaxKindSet.ClassStructRecordTypeDeclarations, canBePartial: false, cancellationToken: cancellationToken))
+            if (context.IsMemberDeclarationContext(validModifiers: s_validNonInterfaceMemberModifiers, validTypeDeclarations: SyntaxKindSet.ClassStructRecordTypeDeclarations, canBePartial: false, cancellationToken: cancellationToken))
             {
                 // operators must be both public and static
                 var modifiers = context.PrecedingModifiers;
@@ -37,6 +45,15 @@ protected override bool IsValidContext(int position, CSharpSyntaxContext context
                     modifiers.Contains(SyntaxKind.PublicKeyword) &&
                     modifiers.Contains(SyntaxKind.StaticKeyword);
             }
+            else if (context.IsMemberDeclarationContext(validModifiers: s_validInterfaceMemberModifiers, validTypeDeclarations: SyntaxKindSet.InterfaceOnlyTypeDeclarations, canBePartial: false, cancellationToken: cancellationToken))
+            {
+                // operators must be both abstract and static
+                var modifiers = context.PrecedingModifiers;
+
+                return
+                    modifiers.Contains(SyntaxKind.AbstractKeyword) &&
+                    modifiers.Contains(SyntaxKind.StaticKeyword);
+            }
 
             return false;
         }
diff --git a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ImplicitKeywordRecommender.cs b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ImplicitKeywordRecommender.cs
index 400b2107e28e3..5ba148272eb74 100644
--- a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ImplicitKeywordRecommender.cs
+++ b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ImplicitKeywordRecommender.cs
@@ -13,7 +13,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Completion.KeywordRecommenders
 {
     internal class ImplicitKeywordRecommender : AbstractSyntacticSingleKeywordRecommender
     {
-        private static readonly ISet<SyntaxKind> s_validMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        private static readonly ISet<SyntaxKind> s_validNonInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
             {
                 SyntaxKind.StaticKeyword,
                 SyntaxKind.PublicKeyword,
@@ -21,6 +21,14 @@ internal class ImplicitKeywordRecommender : AbstractSyntacticSingleKeywordRecomm
                 SyntaxKind.UnsafeKeyword,
             };
 
+        private static readonly ISet<SyntaxKind> s_validInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+            {
+                SyntaxKind.StaticKeyword,
+                SyntaxKind.PublicKeyword,
+                SyntaxKind.AbstractKeyword,
+                SyntaxKind.UnsafeKeyword,
+            };
+
         public ImplicitKeywordRecommender()
             : base(SyntaxKind.ImplicitKeyword)
         {
@@ -28,7 +36,7 @@ public ImplicitKeywordRecommender()
 
         protected override bool IsValidContext(int position, CSharpSyntaxContext context, CancellationToken cancellationToken)
         {
-            if (context.IsMemberDeclarationContext(validModifiers: s_validMemberModifiers, validTypeDeclarations: SyntaxKindSet.ClassStructRecordTypeDeclarations, canBePartial: false, cancellationToken: cancellationToken))
+            if (context.IsMemberDeclarationContext(validModifiers: s_validNonInterfaceMemberModifiers, validTypeDeclarations: SyntaxKindSet.ClassStructRecordTypeDeclarations, canBePartial: false, cancellationToken: cancellationToken))
             {
                 // operators must be both public and static
                 var modifiers = context.PrecedingModifiers;
@@ -37,6 +45,15 @@ protected override bool IsValidContext(int position, CSharpSyntaxContext context
                     modifiers.Contains(SyntaxKind.PublicKeyword) &&
                     modifiers.Contains(SyntaxKind.StaticKeyword);
             }
+            else if (context.IsMemberDeclarationContext(validModifiers: s_validInterfaceMemberModifiers, validTypeDeclarations: SyntaxKindSet.InterfaceOnlyTypeDeclarations, canBePartial: false, cancellationToken: cancellationToken))
+            {
+                // operators must be both abstract and static
+                var modifiers = context.PrecedingModifiers;
+
+                return
+                    modifiers.Contains(SyntaxKind.AbstractKeyword) &&
+                    modifiers.Contains(SyntaxKind.StaticKeyword);
+            }
 
             return false;
         }
diff --git a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/RecordKeywordRecommender.cs b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/RecordKeywordRecommender.cs
index 540f5870c92b2..a339e12eac4c0 100644
--- a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/RecordKeywordRecommender.cs
+++ b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/RecordKeywordRecommender.cs
@@ -24,6 +24,7 @@ internal class RecordKeywordRecommender : AbstractSyntacticSingleKeywordRecommen
                 SyntaxKind.SealedKeyword,
                 SyntaxKind.StaticKeyword,
                 SyntaxKind.UnsafeKeyword,
+                SyntaxKind.ReadOnlyKeyword,
             };
 
         public RecordKeywordRecommender()
diff --git a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/SealedKeywordRecommender.cs b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/SealedKeywordRecommender.cs
index c0d5275af6e05..f32f0bf357d36 100644
--- a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/SealedKeywordRecommender.cs
+++ b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/SealedKeywordRecommender.cs
@@ -13,7 +13,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Completion.KeywordRecommenders
 {
     internal class SealedKeywordRecommender : AbstractSyntacticSingleKeywordRecommender
     {
-        private static readonly ISet<SyntaxKind> s_validMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        private static readonly ISet<SyntaxKind> s_validNonInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
         {
             SyntaxKind.ExternKeyword,
             SyntaxKind.InternalKeyword,
@@ -24,6 +24,18 @@ internal class SealedKeywordRecommender : AbstractSyntacticSingleKeywordRecommen
             SyntaxKind.UnsafeKeyword,
         };
 
+        private static readonly ISet<SyntaxKind> s_validInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        {
+            SyntaxKind.ExternKeyword,
+            SyntaxKind.InternalKeyword,
+            SyntaxKind.NewKeyword,
+            SyntaxKind.OverrideKeyword,
+            SyntaxKind.PublicKeyword,
+            SyntaxKind.ProtectedKeyword,
+            SyntaxKind.StaticKeyword,
+            SyntaxKind.UnsafeKeyword,
+        };
+
         private static readonly ISet<SyntaxKind> s_validTypeModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
         {
             SyntaxKind.InternalKeyword,
@@ -44,8 +56,13 @@ protected override bool IsValidContext(int position, CSharpSyntaxContext context
             return
                 context.IsGlobalStatementContext ||
                 context.IsMemberDeclarationContext(
-                    validModifiers: s_validMemberModifiers,
-                    validTypeDeclarations: SyntaxKindSet.ClassInterfaceRecordTypeDeclarations,
+                    validModifiers: s_validNonInterfaceMemberModifiers,
+                    validTypeDeclarations: SyntaxKindSet.ClassRecordTypeDeclarations,
+                    canBePartial: false,
+                    cancellationToken: cancellationToken) ||
+                context.IsMemberDeclarationContext(
+                    validModifiers: s_validInterfaceMemberModifiers,
+                    validTypeDeclarations: SyntaxKindSet.InterfaceOnlyTypeDeclarations,
                     canBePartial: false,
                     cancellationToken: cancellationToken) ||
                 context.IsTypeDeclarationContext(
diff --git a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/StaticKeywordRecommender.cs b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/StaticKeywordRecommender.cs
index a9228a2537c46..0df962ed64606 100644
--- a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/StaticKeywordRecommender.cs
+++ b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/StaticKeywordRecommender.cs
@@ -23,7 +23,7 @@ internal class StaticKeywordRecommender : AbstractSyntacticSingleKeywordRecommen
             SyntaxKind.UnsafeKeyword,
         };
 
-        private static readonly ISet<SyntaxKind> s_validMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        private static readonly ISet<SyntaxKind> s_validNonInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
         {
             SyntaxKind.AsyncKeyword,
             SyntaxKind.ExternKeyword,
@@ -37,6 +37,22 @@ internal class StaticKeywordRecommender : AbstractSyntacticSingleKeywordRecommen
             SyntaxKind.VolatileKeyword,
         };
 
+        private static readonly ISet<SyntaxKind> s_validInterfaceMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        {
+            SyntaxKind.AbstractKeyword,
+            SyntaxKind.AsyncKeyword,
+            SyntaxKind.ExternKeyword,
+            SyntaxKind.InternalKeyword,
+            SyntaxKind.NewKeyword,
+            SyntaxKind.PublicKeyword,
+            SyntaxKind.PrivateKeyword,
+            SyntaxKind.ProtectedKeyword,
+            SyntaxKind.ReadOnlyKeyword,
+            SyntaxKind.SealedKeyword,
+            SyntaxKind.UnsafeKeyword,
+            SyntaxKind.VolatileKeyword,
+        };
+
         private static readonly ISet<SyntaxKind> s_validGlobalMemberModifiers = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
         {
             SyntaxKind.ExternKeyword,
@@ -77,8 +93,13 @@ private static bool IsValidContextForMember(CSharpSyntaxContext context, Cancell
             return
                 context.SyntaxTree.IsGlobalMemberDeclarationContext(context.Position, s_validGlobalMemberModifiers, cancellationToken) ||
                 context.IsMemberDeclarationContext(
-                    validModifiers: s_validMemberModifiers,
-                    validTypeDeclarations: SyntaxKindSet.ClassInterfaceStructRecordTypeDeclarations,
+                    validModifiers: s_validNonInterfaceMemberModifiers,
+                    validTypeDeclarations: SyntaxKindSet.ClassStructRecordTypeDeclarations,
+                    canBePartial: false,
+                    cancellationToken: cancellationToken) ||
+                context.IsMemberDeclarationContext(
+                    validModifiers: s_validInterfaceMemberModifiers,
+                    validTypeDeclarations: SyntaxKindSet.InterfaceOnlyTypeDeclarations,
                     canBePartial: false,
                     cancellationToken: cancellationToken);
         }
diff --git a/src/Features/CSharp/Portable/ConvertLinq/CSharpConvertLinqQueryToForEachProvider.cs b/src/Features/CSharp/Portable/ConvertLinq/CSharpConvertLinqQueryToForEachProvider.cs
index ae07a09397454..9abe07d9867dd 100644
--- a/src/Features/CSharp/Portable/ConvertLinq/CSharpConvertLinqQueryToForEachProvider.cs
+++ b/src/Features/CSharp/Portable/ConvertLinq/CSharpConvertLinqQueryToForEachProvider.cs
@@ -260,6 +260,7 @@ private bool CanTryConvertToLocalFunction()
                     {
                         return true;
                     }
+
                     if (currentNode is ExpressionSyntax ||
                         currentNode is ArgumentSyntax ||
                         currentNode is ArgumentListSyntax ||
diff --git a/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs b/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs
index 536701ea63cd6..b55a9e9a39ab9 100644
--- a/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs
+++ b/src/Features/CSharp/Portable/EditAndContinue/CSharpEditAndContinueAnalyzer.cs
@@ -1133,6 +1133,7 @@ record.ParameterList is not null &&
                     }
                 }
             }
+
             return false;
         }
 
@@ -1145,6 +1146,7 @@ internal override bool IsPropertyAccessorDeclarationMatchingPrimaryConstructorPa
                 isFirstAccessor = list.Accessors[0] == declaration;
                 return true;
             }
+
             return false;
         }
 
@@ -1179,7 +1181,10 @@ protected override SyntaxNode GetSymbolDeclarationSyntax(SyntaxReference referen
                     Contract.ThrowIfNull(oldNode);
                     Contract.ThrowIfNull(newNode);
 
-                    // Either old or new property/indexer has an expression body (or both do).
+                    // Certain updates of a property/indexer node affects its accessors.
+                    // Return all affected symbols for these updates.
+
+                    // 1) Old or new property/indexer has an expression body:
                     //   int this[...] => expr;
                     //   int this[...] { get => expr; }
                     //   int P => expr;
@@ -1196,6 +1201,36 @@ protected override SyntaxNode GetSymbolDeclarationSyntax(SyntaxReference referen
                         return OneOrMany.Create(ImmutableArray.Create((oldSymbol, newSymbol), (oldGetterSymbol, newGetterSymbol)));
                     }
 
+                    // 2) Property/indexer declarations differ in readonly keyword.
+                    if (oldNode is PropertyDeclarationSyntax oldProperty && newNode is PropertyDeclarationSyntax newProperty && DiffersInReadOnlyModifier(oldProperty.Modifiers, newProperty.Modifiers) ||
+                        oldNode is IndexerDeclarationSyntax oldIndexer && newNode is IndexerDeclarationSyntax newIndexer && DiffersInReadOnlyModifier(oldIndexer.Modifiers, newIndexer.Modifiers))
+                    {
+                        Debug.Assert(oldSymbol is IPropertySymbol);
+                        Debug.Assert(newSymbol is IPropertySymbol);
+
+                        var oldPropertySymbol = (IPropertySymbol)oldSymbol;
+                        var newPropertySymbol = (IPropertySymbol)newSymbol;
+
+                        using var _ = ArrayBuilder<(ISymbol?, ISymbol?)>.GetInstance(out var builder);
+
+                        builder.Add((oldPropertySymbol, newPropertySymbol));
+
+                        if (oldPropertySymbol.GetMethod != null && newPropertySymbol.GetMethod != null && oldPropertySymbol.GetMethod.IsReadOnly != newPropertySymbol.GetMethod.IsReadOnly)
+                        {
+                            builder.Add((oldPropertySymbol.GetMethod, newPropertySymbol.GetMethod));
+                        }
+
+                        if (oldPropertySymbol.SetMethod != null && newPropertySymbol.SetMethod != null && oldPropertySymbol.SetMethod.IsReadOnly != newPropertySymbol.SetMethod.IsReadOnly)
+                        {
+                            builder.Add((oldPropertySymbol.SetMethod, newPropertySymbol.SetMethod));
+                        }
+
+                        return OneOrMany.Create(builder.ToImmutable());
+                    }
+
+                    static bool DiffersInReadOnlyModifier(SyntaxTokenList oldModifiers, SyntaxTokenList newModifiers)
+                        => (oldModifiers.IndexOf(SyntaxKind.ReadOnlyKeyword) >= 0) != (newModifiers.IndexOf(SyntaxKind.ReadOnlyKeyword) >= 0);
+
                     break;
 
                 case EditKind.Delete:
@@ -1249,6 +1284,7 @@ protected override SyntaxNode GetSymbolDeclarationSyntax(SyntaxReference referen
                     {
                         parameterSymbol = invokeMethodSymbol.ContainingSymbol;
                     }
+
                     return parameterSymbol;
                 }
 
@@ -2298,6 +2334,7 @@ private void ClassifyInsert(SyntaxNode node)
                         {
                             ReportError(RudeEditKind.Insert);
                         }
+
                         return;
 
                     case SyntaxKind.EnumMemberDeclaration:
@@ -2318,6 +2355,7 @@ private void ClassifyInsert(SyntaxNode node)
                         {
                             ReportError(RudeEditKind.Insert);
                         }
+
                         return;
                 }
 
@@ -2409,6 +2447,7 @@ private void ClassifyDelete(SyntaxNode oldNode)
                         {
                             ReportError(RudeEditKind.Delete);
                         }
+
                         return;
 
                     case SyntaxKind.TypeParameter:
@@ -2427,6 +2466,7 @@ private void ClassifyDelete(SyntaxNode oldNode)
                         {
                             ReportError(RudeEditKind.Delete);
                         }
+
                         return;
                 }
 
@@ -2564,6 +2604,7 @@ private void ClassifyUpdate(SyntaxNode oldNode, SyntaxNode newNode)
                         {
                             ReportError(RudeEditKind.Update);
                         }
+
                         return;
 
                     case SyntaxKind.TypeParameterList:
@@ -2589,19 +2630,6 @@ private void ClassifyUpdate(NamespaceDeclarationSyntax oldNode, NamespaceDeclara
 
             private void ClassifyUpdate(TypeDeclarationSyntax oldNode, TypeDeclarationSyntax newNode)
             {
-                if (oldNode.Kind() != newNode.Kind())
-                {
-                    ReportError(RudeEditKind.TypeKindUpdate);
-                    return;
-                }
-
-                // Allow partial keyword to be added or removed.
-                if (!AreModifiersEquivalent(oldNode.Modifiers, newNode.Modifiers, ignore: SyntaxKind.PartialKeyword, ignore2: SyntaxKind.UnsafeKeyword))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 if (!SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier))
                 {
                     ReportError(RudeEditKind.Renamed);
@@ -2622,12 +2650,6 @@ private void ClassifyUpdate(EnumDeclarationSyntax oldNode, EnumDeclarationSyntax
                     return;
                 }
 
-                if (!SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 if (!SyntaxFactory.AreEquivalent(oldNode.BaseList, newNode.BaseList))
                 {
                     ReportError(RudeEditKind.EnumUnderlyingTypeUpdate);
@@ -2640,12 +2662,6 @@ private void ClassifyUpdate(EnumDeclarationSyntax oldNode, EnumDeclarationSyntax
 
             private void ClassifyUpdate(DelegateDeclarationSyntax oldNode, DelegateDeclarationSyntax newNode)
             {
-                if (!AreModifiersEquivalent(oldNode.Modifiers, newNode.Modifiers, ignore: SyntaxKind.UnsafeKeyword))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 if (!SyntaxFactory.AreEquivalent(oldNode.ReturnType, newNode.ReturnType))
                 {
                     ReportError(RudeEditKind.TypeUpdate);
@@ -2665,12 +2681,6 @@ private void ClassifyUpdate(BaseFieldDeclarationSyntax oldNode, BaseFieldDeclara
                     ReportError(RudeEditKind.FieldKindUpdate);
                     return;
                 }
-
-                if (!AreModifiersEquivalent(oldNode.Modifiers, newNode.Modifiers, ignore: SyntaxKind.UnsafeKeyword))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
             }
 
             private void ClassifyUpdate(VariableDeclarationSyntax oldNode, VariableDeclarationSyntax newNode)
@@ -2729,13 +2739,6 @@ private void ClassifyUpdate(MethodDeclarationSyntax oldNode, MethodDeclarationSy
                     return;
                 }
 
-                // Ignore async keyword when matching modifiers. Async checks are done in ComputeBodyMatch.
-                if (!AreModifiersEquivalent(oldNode.Modifiers, newNode.Modifiers, ignore: SyntaxKind.AsyncKeyword, ignore2: SyntaxKind.UnsafeKeyword))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 if (!SyntaxFactory.AreEquivalent(oldNode.ReturnType, newNode.ReturnType))
                 {
                     ReportError(RudeEditKind.TypeUpdate);
@@ -2757,15 +2760,9 @@ private void ClassifyUpdate(MethodDeclarationSyntax oldNode, MethodDeclarationSy
 
             private void ClassifyUpdate(ConversionOperatorDeclarationSyntax oldNode, ConversionOperatorDeclarationSyntax newNode)
             {
-                if (!SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 if (!SyntaxFactory.AreEquivalent(oldNode.ImplicitOrExplicitKeyword, newNode.ImplicitOrExplicitKeyword))
                 {
-                    ReportError(RudeEditKind.Renamed);
+                    ReportError(RudeEditKind.ModifiersUpdate);
                     return;
                 }
 
@@ -2784,12 +2781,6 @@ private void ClassifyUpdate(ConversionOperatorDeclarationSyntax oldNode, Convers
 
             private void ClassifyUpdate(OperatorDeclarationSyntax oldNode, OperatorDeclarationSyntax newNode)
             {
-                if (!SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 if (!SyntaxFactory.AreEquivalent(oldNode.OperatorToken, newNode.OperatorToken))
                 {
                     ReportError(RudeEditKind.Renamed);
@@ -2811,12 +2802,6 @@ private void ClassifyUpdate(OperatorDeclarationSyntax oldNode, OperatorDeclarati
 
             private void ClassifyUpdate(AccessorDeclarationSyntax oldNode, AccessorDeclarationSyntax newNode)
             {
-                if (!SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 if (oldNode.Kind() != newNode.Kind())
                 {
                     ReportError(RudeEditKind.AccessorKindUpdate);
@@ -2852,12 +2837,6 @@ private void ClassifyUpdate(EnumMemberDeclarationSyntax oldNode, EnumMemberDecla
 
             private void ClassifyUpdate(ConstructorDeclarationSyntax oldNode, ConstructorDeclarationSyntax newNode)
             {
-                if (!AreModifiersEquivalent(oldNode.Modifiers, newNode.Modifiers, ignore: SyntaxKind.UnsafeKeyword))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 ClassifyMethodBodyRudeUpdate(
                     (SyntaxNode?)oldNode.Body ?? oldNode.ExpressionBody?.Expression,
                     (SyntaxNode?)newNode.Body ?? newNode.ExpressionBody?.Expression,
@@ -2876,12 +2855,6 @@ private void ClassifyUpdate(DestructorDeclarationSyntax oldNode, DestructorDecla
 
             private void ClassifyUpdate(PropertyDeclarationSyntax oldNode, PropertyDeclarationSyntax newNode)
             {
-                if (!AreModifiersEquivalent(oldNode.Modifiers, newNode.Modifiers, ignore: SyntaxKind.UnsafeKeyword))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 if (!SyntaxFactory.AreEquivalent(oldNode.Type, newNode.Type))
                 {
                     ReportError(RudeEditKind.TypeUpdate);
@@ -2936,12 +2909,6 @@ private void ClassifyUpdate(PropertyDeclarationSyntax oldNode, PropertyDeclarati
 
             private void ClassifyUpdate(IndexerDeclarationSyntax oldNode, IndexerDeclarationSyntax newNode)
             {
-                if (!SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers))
-                {
-                    ReportError(RudeEditKind.ModifiersUpdate);
-                    return;
-                }
-
                 if (!SyntaxFactory.AreEquivalent(oldNode.Type, newNode.Type))
                 {
                     ReportError(RudeEditKind.TypeUpdate);
@@ -2954,16 +2921,17 @@ private void ClassifyUpdate(IndexerDeclarationSyntax oldNode, IndexerDeclaration
                     return;
                 }
 
-                Debug.Assert(!SyntaxFactory.AreEquivalent(oldNode.ExpressionBody, newNode.ExpressionBody));
-
-                var oldBody = SyntaxUtilities.TryGetEffectiveGetterBody(oldNode.ExpressionBody, oldNode.AccessorList);
-                var newBody = SyntaxUtilities.TryGetEffectiveGetterBody(newNode.ExpressionBody, newNode.AccessorList);
+                if (SyntaxFactory.AreEquivalent(oldNode.ExpressionBody, newNode.ExpressionBody))
+                {
+                    var oldBody = SyntaxUtilities.TryGetEffectiveGetterBody(oldNode.ExpressionBody, oldNode.AccessorList);
+                    var newBody = SyntaxUtilities.TryGetEffectiveGetterBody(newNode.ExpressionBody, newNode.AccessorList);
 
-                ClassifyMethodBodyRudeUpdate(
-                    oldBody,
-                    newBody,
-                    containingMethod: null,
-                    containingType: (TypeDeclarationSyntax?)newNode.Parent);
+                    ClassifyMethodBodyRudeUpdate(
+                        oldBody,
+                        newBody,
+                        containingMethod: null,
+                        containingType: (TypeDeclarationSyntax?)newNode.Parent);
+                }
             }
 
             private void ClassifyUpdate(TypeParameterSyntax oldNode, TypeParameterSyntax newNode)
diff --git a/src/Features/CSharp/Portable/EditAndContinue/SyntaxComparer.cs b/src/Features/CSharp/Portable/EditAndContinue/SyntaxComparer.cs
index 8a4aa880d6630..84384afef4d08 100644
--- a/src/Features/CSharp/Portable/EditAndContinue/SyntaxComparer.cs
+++ b/src/Features/CSharp/Portable/EditAndContinue/SyntaxComparer.cs
@@ -626,6 +626,7 @@ private static Label ClassifyTopSyntax(SyntaxKind kind, SyntaxNode? node, out bo
                     {
                         return Label.AttributeList;
                     }
+
                     break;
 
                 case SyntaxKind.Attribute:
@@ -635,6 +636,7 @@ private static Label ClassifyTopSyntax(SyntaxKind kind, SyntaxNode? node, out bo
                         isLeaf = true;
                         return Label.Attribute;
                     }
+
                     break;
             }
 
@@ -1265,6 +1267,7 @@ private static void GetLocalNames(ExpressionSyntax expression, ref List<SyntaxTo
                     {
                         GetLocalNames(argument.Expression, ref result);
                     }
+
                     return;
 
                 default:
@@ -1287,6 +1290,7 @@ private static void GetLocalNames(VariableDesignationSyntax designation, ref Lis
                     {
                         GetLocalNames(variableDesignation, ref result);
                     }
+
                     return;
 
                 case SyntaxKind.DiscardDesignation:
diff --git a/src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.PostProcessor.cs b/src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.PostProcessor.cs
index 0b9c0697f4288..bbda6487d17e4 100644
--- a/src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.PostProcessor.cs
+++ b/src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.PostProcessor.cs
@@ -229,6 +229,7 @@ public static ImmutableArray<StatementSyntax> RemoveInitializedDeclarationAndRet
                 {
                     return statements;
                 }
+
                 if (!(statements.ElementAtOrDefault(0) is LocalDeclarationStatementSyntax declaration) || !(statements.ElementAtOrDefault(1) is ReturnStatementSyntax returnStatement))
                 {
                     return statements;
diff --git a/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs b/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs
index d038b32461384..093da30d31508 100644
--- a/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs
+++ b/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs
@@ -109,6 +109,7 @@ public async Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(
                 var inferredIndentationService = document.Project.Solution.Workspace.Services.GetRequiredService<IInferredIndentationService>();
                 options = await inferredIndentationService.GetDocumentOptionsWithInferredIndentationAsync(document, explicitFormat: true, cancellationToken: cancellationToken).ConfigureAwait(false);
             }
+
             return Formatter.GetFormattedTextChanges(root,
                 SpecializedCollections.SingletonEnumerable(formattingSpan),
                 document.Project.Solution.Workspace, options, cancellationToken).ToImmutableArray();
diff --git a/src/Features/CSharp/Portable/ImplementInterface/AbstractChangeImplementionCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ImplementInterface/AbstractChangeImplementionCodeRefactoringProvider.cs
index e28eb764dea36..a8456785be94a 100644
--- a/src/Features/CSharp/Portable/ImplementInterface/AbstractChangeImplementionCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/ImplementInterface/AbstractChangeImplementionCodeRefactoringProvider.cs
@@ -171,6 +171,7 @@ private static int TotalCount(MemberImplementationMap dictionary)
             {
                 result += values.Count;
             }
+
             return result;
         }
 
diff --git a/src/Features/CSharp/Portable/ImplementInterface/CSharpImplementInterfaceCodeFixProvider.cs b/src/Features/CSharp/Portable/ImplementInterface/CSharpImplementInterfaceCodeFixProvider.cs
index c38665713bb6b..89c738968cc5f 100644
--- a/src/Features/CSharp/Portable/ImplementInterface/CSharpImplementInterfaceCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/ImplementInterface/CSharpImplementInterfaceCodeFixProvider.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Collections.Immutable;
 using System.Composition;
@@ -42,7 +40,7 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             var span = context.Span;
             var cancellationToken = context.CancellationToken;
 
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
             var token = root.FindToken(span.Start);
             if (!token.Span.IntersectsWith(span))
@@ -50,7 +48,7 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 return;
             }
 
-            var service = document.GetLanguageService<IImplementInterfaceService>();
+            var service = document.GetRequiredLanguageService<IImplementInterfaceService>();
             var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
             var actions = token.Parent.GetAncestorsOrThis<TypeSyntax>()
diff --git a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
index acb3bf5e62e40..cc423d436e8a3 100644
--- a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
+++ b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
@@ -42,6 +42,7 @@ public CSharpInlineTypeHintsService()
                     if (IsValidType(type))
                         return CreateTypeHint(type, displayAllOverride, forImplicitVariableTypes, variableDeclaration.Type, variableDeclaration.Variables[0].Identifier);
                 }
+
                 if (node is DeclarationExpressionSyntax { Type: { IsVar: true } } declarationExpression)
                 {
                     var type = semanticModel.GetTypeInfo(declarationExpression.Type, cancellationToken).Type;
diff --git a/src/Features/CSharp/Portable/InvertIf/CSharpInvertIfCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/InvertIf/CSharpInvertIfCodeRefactoringProvider.cs
index 5bfa5c6d16756..90060995990ee 100644
--- a/src/Features/CSharp/Portable/InvertIf/CSharpInvertIfCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/InvertIf/CSharpInvertIfCodeRefactoringProvider.cs
@@ -2,8 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
+using System;
 using System.Collections.Generic;
 using System.Composition;
 using System.Diagnostics.CodeAnalysis;
@@ -41,7 +40,7 @@ protected override SyntaxNode GetCondition(IfStatementSyntax ifNode)
             => ifNode.Condition;
 
         protected override StatementRange GetIfBodyStatementRange(IfStatementSyntax ifNode)
-            => new StatementRange(ifNode.Statement, ifNode.Statement);
+            => new(ifNode.Statement, ifNode.Statement);
 
         protected override bool IsStatementContainer(SyntaxNode node)
             => node.IsKind(SyntaxKind.Block, SyntaxKind.SwitchSection);
@@ -52,7 +51,7 @@ protected override bool IsNoOpSyntaxNode(SyntaxNode node)
         protected override bool IsExecutableStatement(SyntaxNode node)
             => node is StatementSyntax;
 
-        protected override StatementSyntax GetNextStatement(StatementSyntax node)
+        protected override StatementSyntax? GetNextStatement(StatementSyntax node)
             => node.GetNextStatement();
 
         protected override StatementSyntax GetIfBody(IfStatementSyntax ifNode)
@@ -62,7 +61,7 @@ protected override StatementSyntax GetEmptyEmbeddedStatement()
             => SyntaxFactory.Block();
 
         protected override StatementSyntax GetElseBody(IfStatementSyntax ifNode)
-            => ifNode.Else.Statement;
+            => ifNode.Else?.Statement ?? throw new InvalidOperationException();
 
         protected override bool CanControlFlowOut(SyntaxNode node)
         {
@@ -154,7 +153,7 @@ protected override IfStatementSyntax UpdateIf(
             IfStatementSyntax ifNode,
             SyntaxNode condition,
             StatementSyntax trueStatement,
-            StatementSyntax falseStatementOpt = null)
+            StatementSyntax? falseStatementOpt = null)
         {
             var isSingleLine = sourceText.AreOnSameLine(ifNode.GetFirstToken(), ifNode.GetLastToken());
             if (isSingleLine && falseStatementOpt != null)
@@ -175,7 +174,7 @@ protected override IfStatementSyntax UpdateIf(
                     ? SyntaxFactory.Block(trueStatement)
                     : trueStatement);
 
-            if (falseStatementOpt != null)
+            if (ShouldKeepFalse(ifNode, falseStatementOpt))
             {
                 var elseClause = updatedIf.Else != null
                     ? updatedIf.Else.WithStatement(falseStatementOpt)
@@ -183,6 +182,10 @@ protected override IfStatementSyntax UpdateIf(
 
                 updatedIf = updatedIf.WithElse(elseClause);
             }
+            else
+            {
+                updatedIf = updatedIf.WithElse(null);
+            }
 
             // If this is multiline, format things after we swap around the if/else.  Because 
             // of all the different types of rewriting, we may need indentation fixed up and
@@ -193,6 +196,50 @@ protected override IfStatementSyntax UpdateIf(
                 : updatedIf.WithAdditionalAnnotations(Formatter.Annotation);
         }
 
+        private static bool ShouldKeepFalse(IfStatementSyntax originalIfStatement, [NotNullWhen(returnValue: true)] StatementSyntax? falseStatement)
+        {
+            // The original false statement doesn't exist at all
+            // then no need to consider keeping it around
+            if (falseStatement is null)
+            {
+                return false;
+            }
+
+            if (falseStatement is BlockSyntax falseBlock)
+            {
+                // Block false syntax with some statements included.
+                // If there are no statements, it's an empty
+                // block and we can get rid of it.
+                if (falseBlock.Statements.Any())
+                {
+                    return true;
+                }
+
+                // If the stateements for the else don't pass, we still need to check
+                // if there are comments from the original if that should be included.
+                // If so, pass them along to be copied to the new else block
+                return originalIfStatement.Statement is BlockSyntax block
+                    && BlockHasComment(block);
+            }
+
+            // The statement is not expected to have children, so we know it's fine
+            // to consider this something that needs to be included. Such as 
+            // a return statement, or other similar things for single line if/else.
+            return true;
+
+            static bool BlockHasComment(BlockSyntax block)
+            {
+                return block.CloseBraceToken.LeadingTrivia.Any(HasCommentTrivia)
+                    || block.OpenBraceToken.TrailingTrivia.Any(HasCommentTrivia);
+            }
+
+            static bool HasCommentTrivia(SyntaxTrivia trivia)
+            {
+                return trivia.IsKind(SyntaxKind.MultiLineCommentTrivia)
+                   || trivia.IsKind(SyntaxKind.SingleLineCommentTrivia);
+            }
+        }
+
         protected override SyntaxNode WithStatements(SyntaxNode node, IEnumerable<StatementSyntax> statements)
         {
             switch (node)
diff --git a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeRefactoringProvider.cs
index 233566094f888..2132e02303889 100644
--- a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeRefactoringProvider.cs
@@ -27,7 +27,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             var (document, textSpan, cancellationToken) = context;
 
             var syntaxTree = (await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false))!;
-            if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(syntaxTree))
+            if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(((CSharpParseOptions)syntaxTree.Options).LanguageVersion))
             {
                 return;
             }
diff --git a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/PassInCapturedVariablesAsArgumentsCodeFixProvider.cs b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/PassInCapturedVariablesAsArgumentsCodeFixProvider.cs
index f1d0a0b23f14c..d2d9b23211f3c 100644
--- a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/PassInCapturedVariablesAsArgumentsCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/PassInCapturedVariablesAsArgumentsCodeFixProvider.cs
@@ -78,7 +78,7 @@ private static async Task WrapFixAsync(
 
             // Even when the language version doesn't support staic local function, the compiler will still
             // generate this error. So we need to check to make sure we don't provide incorrect fix.
-            if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(root.SyntaxTree))
+            if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(((CSharpParseOptions)root.SyntaxTree.Options).LanguageVersion))
             {
                 return;
             }
diff --git a/src/Features/CSharp/Portable/MakeTypeAbstract/CSharpMakeTypeAbstractCodeFixProvider.cs b/src/Features/CSharp/Portable/MakeTypeAbstract/CSharpMakeTypeAbstractCodeFixProvider.cs
index e39ddd3c9fd3b..9a581c6b3ab05 100644
--- a/src/Features/CSharp/Portable/MakeTypeAbstract/CSharpMakeTypeAbstractCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/MakeTypeAbstract/CSharpMakeTypeAbstractCodeFixProvider.cs
@@ -36,6 +36,7 @@ protected override bool IsValidRefactoringContext(SyntaxNode? node, [NotNullWhen
                         typeDeclaration = null;
                         return false;
                     }
+
                     break;
 
                 case AccessorDeclarationSyntax accessor:
@@ -44,6 +45,7 @@ protected override bool IsValidRefactoringContext(SyntaxNode? node, [NotNullWhen
                         typeDeclaration = null;
                         return false;
                     }
+
                     break;
 
                 default:
diff --git a/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs b/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs
index c2c3121c882b6..4e7f37db9d9f4 100644
--- a/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs
+++ b/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs
@@ -276,6 +276,7 @@ private static MethodDeclarationSyntax GetGetMethodWorker(
                                             .WithExpressionBody(getAccessorDeclaration.ExpressionBody)
                                             .WithSemicolonToken(getAccessorDeclaration.SemicolonToken);
                 }
+
                 if (getAccessorDeclaration?.Body != null)
                 {
                     return methodDeclaration.WithBody(getAccessorDeclaration.Body)
diff --git a/src/Features/CSharp/Portable/UpgradeProject/CSharpUpgradeProjectCodeFixProvider.cs b/src/Features/CSharp/Portable/UpgradeProject/CSharpUpgradeProjectCodeFixProvider.cs
index b79e74ef15c73..30c60d39781ed 100644
--- a/src/Features/CSharp/Portable/UpgradeProject/CSharpUpgradeProjectCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UpgradeProject/CSharpUpgradeProjectCodeFixProvider.cs
@@ -43,10 +43,12 @@ public CSharpUpgradeProjectCodeFixProvider()
                 "CS8511", // error CS8511: An expression of type 'T' cannot be handled by a pattern of type '<null>'. Please use language version 'preview' or greater to match an open type with a constant pattern.
                 "CS8627", // error CS8627: A nullable type parameter must be known to be a value type or non-nullable reference type unless language version '{0}' or greater is used. Consider changing the language version or adding a 'class', 'struct', or type constraint.
                 "CS8652", // error CS8652: The feature '' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                "CS8773", // error CS8773: Feature is not available in C# 9.0. Please use language version X or greater.
                 "CS8703", // error CS8703: The modifier '{0}' is not valid for this item in C# {1}. Please use language version '{2}' or greater.
                 "CS8706", // error CS8706: '{0}' cannot implement interface member '{1}' in type '{2}' because feature '{3}' is not available in C# {4}. Please use language version '{5}' or greater. 
                 "CS8904", // error CS8904: Invalid variance: The type parameter 'T1' must be contravariantly valid on 'I2<T1, T2>.M1(T1)' unless language version 'preview' or greater is used. 'T1' is covariant.
                 "CS8912", // error CS8912: Inheriting from a record with a sealed 'Object.ToString' is not supported in C# {0}. Please use language version '{1}' or greater.
+                "CS8704", // error CS8704: 'Test1' does not implement interface member 'I1.M1()'. 'Test1.M1()' cannot implicitly implement a non-public member in C# 9.0. Please use language version 'preview' or greater.
             });
 
         public override string UpgradeThisProjectResource => CSharpFeaturesResources.Upgrade_this_project_to_csharp_language_version_0;
diff --git a/src/Features/Core/Portable/CodeCleanup/DiagnosticSet.cs b/src/Features/Core/Portable/CodeCleanup/DiagnosticSet.cs
index 79843492db80d..29fd7b4dbd97e 100644
--- a/src/Features/Core/Portable/CodeCleanup/DiagnosticSet.cs
+++ b/src/Features/Core/Portable/CodeCleanup/DiagnosticSet.cs
@@ -21,4 +21,4 @@ public DiagnosticSet(string description, params string[] diagnosticIds)
             DiagnosticIds = ImmutableArray.Create(diagnosticIds);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Features/Core/Portable/CodeRefactorings/AddAwait/AbstractAddAwaitCodeRefactoringProvider.cs b/src/Features/Core/Portable/CodeRefactorings/AddAwait/AbstractAddAwaitCodeRefactoringProvider.cs
index 32139f9b2d9e9..b072c25983350 100644
--- a/src/Features/Core/Portable/CodeRefactorings/AddAwait/AbstractAddAwaitCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/AddAwait/AbstractAddAwaitCodeRefactoringProvider.cs
@@ -46,7 +46,7 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex
             for (var i = expressions.Length - 1; i >= 0; i--)
             {
                 var expression = expressions[i];
-                if (IsValidAwaitableExpression(expression, model, syntaxFacts))
+                if (IsValidAwaitableExpression(model, syntaxFacts, expression, cancellationToken))
                 {
                     context.RegisterRefactoring(
                         new MyCodeAction(
@@ -63,24 +63,28 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex
             }
         }
 
-        private static bool IsValidAwaitableExpression(SyntaxNode invocation, SemanticModel model, ISyntaxFactsService syntaxFacts)
+        private static bool IsValidAwaitableExpression(
+            SemanticModel model, ISyntaxFactsService syntaxFacts, SyntaxNode node, CancellationToken cancellationToken)
         {
-            if (syntaxFacts.IsExpressionOfInvocationExpression(invocation.Parent))
+            if (syntaxFacts.IsExpressionOfInvocationExpression(node.Parent))
             {
                 // Do not offer fix on `MethodAsync()$$.ConfigureAwait()`
                 // Do offer fix on `MethodAsync()$$.Invalid()`
-                if (!model.GetTypeInfo(invocation.GetRequiredParent().GetRequiredParent()).Type.IsErrorType())
+                if (!model.GetTypeInfo(node.GetRequiredParent().GetRequiredParent(), cancellationToken).Type.IsErrorType())
                     return false;
             }
 
-            if (syntaxFacts.IsExpressionOfAwaitExpression(invocation))
+            if (syntaxFacts.IsExpressionOfAwaitExpression(node))
                 return false;
 
-            var type = model.GetTypeInfo(invocation).Type;
-            if (type?.IsAwaitableNonDynamic(model, invocation.SpanStart) == true)
-                return true;
+            // if we're on an actual type symbol itself (like literally `Task`) we don't want to offer to add await.
+            // we only want to add for actual expressions whose type is awaitable, not on the awaitable type itself.
+            var symbol = model.GetSymbolInfo(node, cancellationToken).GetAnySymbol();
+            if (symbol is ITypeSymbol)
+                return false;
 
-            return false;
+            var type = model.GetTypeInfo(node, cancellationToken).Type;
+            return type?.IsAwaitableNonDynamic(model, node.SpanStart) == true;
         }
 
         private static Task<Document> AddAwaitAsync(
diff --git a/src/Features/Core/Portable/CodeRefactorings/MoveType/AbstractMoveTypeService.cs b/src/Features/Core/Portable/CodeRefactorings/MoveType/AbstractMoveTypeService.cs
index 139c4efddf2ec..56077d699a069 100644
--- a/src/Features/Core/Portable/CodeRefactorings/MoveType/AbstractMoveTypeService.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/MoveType/AbstractMoveTypeService.cs
@@ -13,7 +13,9 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -107,6 +109,11 @@ private ImmutableArray<CodeAction> CreateActions(State state, CancellationToken
             var manyTypes = MultipleTopLevelTypeDeclarationInSourceDocument(state.SemanticDocument.Root);
             var isNestedType = IsNestedType(state.TypeNode);
 
+            var syntaxFacts = state.SemanticDocument.Document.GetRequiredLanguageService<ISyntaxFactsService>();
+            var isClassNextToGlobalStatements = manyTypes
+                ? false
+                : ClassNextToGlobalStatements(state.SemanticDocument.Root, syntaxFacts);
+
             var suggestedFileNames = GetSuggestedFileNames(
                 state.TypeNode,
                 isNestedType,
@@ -120,7 +127,9 @@ private ImmutableArray<CodeAction> CreateActions(State state, CancellationToken
             // case 2: This is a nested type, offer to move to new file.
             // case 3: If there is a single type decl in current file, *do not* offer move to new file,
             //         rename actions are sufficient in this case.
-            if (manyTypes || isNestedType)
+            // case 4: If there are top level statements(Global statements) offer to move even
+            //         in cases where there are only one class in the file.
+            if (manyTypes || isNestedType || isClassNextToGlobalStatements)
             {
                 foreach (var fileName in suggestedFileNames)
                 {
@@ -152,6 +161,9 @@ private ImmutableArray<CodeAction> CreateActions(State state, CancellationToken
             return actions.ToImmutable();
         }
 
+        private static bool ClassNextToGlobalStatements(SyntaxNode root, ISyntaxFactsService syntaxFacts)
+            => syntaxFacts.ContainsGlobalStatement(root);
+
         private CodeAction GetCodeAction(State state, string fileName, MoveTypeOperationKind operationKind) =>
             new MoveTypeCodeAction((TService)this, state, operationKind, fileName);
 
diff --git a/src/Features/Core/Portable/Common/GlyphExtensions.cs b/src/Features/Core/Portable/Common/GlyphExtensions.cs
index 0d38774159f19..c011f551c16b8 100644
--- a/src/Features/Core/Portable/Common/GlyphExtensions.cs
+++ b/src/Features/Core/Portable/Common/GlyphExtensions.cs
@@ -208,7 +208,7 @@ private static Glyph GetGlyph(string tag, ImmutableArray<string> allTags)
             return Glyph.None;
         }
 
-        private static Accessibility GetAccessibility(ImmutableArray<string> tags)
+        public static Accessibility GetAccessibility(ImmutableArray<string> tags)
         {
             foreach (var tag in tags)
             {
diff --git a/src/Features/Core/Portable/Common/TaggedTextStyle.cs b/src/Features/Core/Portable/Common/TaggedTextStyle.cs
index cf7a756e86aad..4440b13bb3434 100644
--- a/src/Features/Core/Portable/Common/TaggedTextStyle.cs
+++ b/src/Features/Core/Portable/Common/TaggedTextStyle.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 
 namespace Microsoft.CodeAnalysis
@@ -13,12 +11,14 @@ internal enum TaggedTextStyle
     {
         None = 0,
 
-        Strong = 0x1,
+        Strong = 1 << 0,
+
+        Emphasis = 1 << 1,
 
-        Emphasis = 0x2,
+        Underline = 1 << 2,
 
-        Underline = 0x4,
+        Code = 1 << 3,
 
-        Code = 0x8,
+        PreserveWhitespace = 1 << 4,
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionFilterReason.cs b/src/Features/Core/Portable/Completion/CompletionFilterReason.cs
similarity index 100%
rename from src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionFilterReason.cs
rename to src/Features/Core/Portable/Completion/CompletionFilterReason.cs
diff --git a/src/Features/Core/Portable/Completion/CompletionHelper.cs b/src/Features/Core/Portable/Completion/CompletionHelper.cs
index 4b4b57cef0455..f20f17ac7ab38 100644
--- a/src/Features/Core/Portable/Completion/CompletionHelper.cs
+++ b/src/Features/Core/Portable/Completion/CompletionHelper.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.PatternMatching;
 using Microsoft.CodeAnalysis.Tags;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Completion
 {
@@ -358,5 +359,109 @@ private static int CompareExpandedItem(CompletionItem item1, PatternMatch match1
 
         public static string ConcatNamespace(string? containingNamespace, string name)
             => string.IsNullOrEmpty(containingNamespace) ? name : containingNamespace + "." + name;
+
+        internal static bool TryCreateMatchResult<T>(
+            CompletionHelper completionHelper,
+            CompletionItem item,
+            T editorCompletionItem,
+            string filterText,
+            CompletionTriggerKind initialTriggerKind,
+            CompletionFilterReason filterReason,
+            ImmutableArray<string> recentItems,
+            bool includeMatchSpans,
+            int currentIndex,
+            out MatchResult<T> matchResult)
+        {
+            // Get the match of the given completion item for the pattern provided so far. 
+            // A completion item is checked against the pattern by see if it's 
+            // CompletionItem.FilterText matches the item. That way, the pattern it checked 
+            // against terms like "IList" and not IList<>.
+            // Note that the check on filter text length is purely for efficiency, we should 
+            // get the same result with or without it.
+            var patternMatch = filterText.Length > 0
+                ? completionHelper.GetMatch(item.FilterText, filterText, includeMatchSpans, CultureInfo.CurrentCulture)
+                : null;
+
+            var matchedFilterText = MatchesFilterText(
+                item,
+                filterText,
+                initialTriggerKind,
+                filterReason,
+                recentItems,
+                patternMatch);
+
+            if (matchedFilterText || KeepAllItemsInTheList(initialTriggerKind, filterText))
+            {
+                matchResult = new MatchResult<T>(
+                    item, editorCompletionItem, matchedFilterText: matchedFilterText,
+                    patternMatch: patternMatch, currentIndex);
+
+                return true;
+            }
+
+            matchResult = default;
+            return false;
+
+            static bool MatchesFilterText(
+                CompletionItem item,
+                string filterText,
+                CompletionTriggerKind initialTriggerKind,
+                CompletionFilterReason filterReason,
+                ImmutableArray<string> recentItems,
+                PatternMatch? patternMatch)
+            {
+                // For the deletion we bake in the core logic for how matching should work.
+                // This way deletion feels the same across all languages that opt into deletion 
+                // as a completion trigger.
+
+                // Specifically, to avoid being too aggressive when matching an item during 
+                // completion, we require that the current filter text be a prefix of the 
+                // item in the list.
+                if (filterReason == CompletionFilterReason.Deletion &&
+                    initialTriggerKind == CompletionTriggerKind.Deletion)
+                {
+                    return item.FilterText.GetCaseInsensitivePrefixLength(filterText) > 0;
+                }
+
+                // If the user hasn't typed anything, and this item was preselected, or was in the
+                // MRU list, then we definitely want to include it.
+                if (filterText.Length == 0)
+                {
+                    if (item.Rules.MatchPriority > MatchPriority.Default)
+                    {
+                        return true;
+                    }
+
+                    if (!recentItems.IsDefault && GetRecentItemIndex(recentItems, item) <= 0)
+                    {
+                        return true;
+                    }
+                }
+
+                // Otherwise, the item matches filter text if a pattern match is returned.
+                return patternMatch != null;
+            }
+
+            static int GetRecentItemIndex(ImmutableArray<string> recentItems, CompletionItem item)
+            {
+                var index = recentItems.IndexOf(item.FilterText);
+                return -index;
+            }
+
+            // If the item didn't match the filter text, we still keep it in the list
+            // if one of two things is true:
+            //  1. The user has typed nothing or only typed a single character.  In this case they might
+            //     have just typed the character to get completion.  Filtering out items
+            //     here is not desirable.
+            //
+            //  2. They brought up completion with ctrl-j or through deletion.  In these
+            //     cases we just always keep all the items in the list.
+            static bool KeepAllItemsInTheList(CompletionTriggerKind initialTriggerKind, string filterText)
+            {
+                return filterText.Length <= 1 ||
+                    initialTriggerKind == CompletionTriggerKind.Invoke ||
+                    initialTriggerKind == CompletionTriggerKind.Deletion;
+            }
+        }
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/MatchResult.cs b/src/Features/Core/Portable/Completion/MatchResult.cs
similarity index 74%
rename from src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/MatchResult.cs
rename to src/Features/Core/Portable/Completion/MatchResult.cs
index b13c657baa436..de60e1348c684 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/MatchResult.cs
+++ b/src/Features/Core/Portable/Completion/MatchResult.cs
@@ -5,26 +5,26 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.PatternMatching;
-using Microsoft.VisualStudio.Text;
 using Roslyn.Utilities;
 using RoslynCompletionItem = Microsoft.CodeAnalysis.Completion.CompletionItem;
-using VSCompletionItem = Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data.CompletionItem;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncCompletion
+namespace Microsoft.CodeAnalysis.Completion
 {
-    internal readonly struct MatchResult
+    internal readonly struct MatchResult<TEditorCompletionItem>
     {
         public readonly RoslynCompletionItem RoslynCompletionItem;
         public readonly bool MatchedFilterText;
-        public readonly ImmutableArray<Span> HighlightedSpans;
 
         // In certain cases, there'd be no match but we'd still set `MatchedFilterText` to true,
         // e.g. when the item is in MRU list. Therefore making this nullable.
         public readonly PatternMatch? PatternMatch;
 
-        public readonly VSCompletionItem VSCompletionItem;
+        /// <summary>
+        /// The actual editor completion item associated with this <see cref="RoslynCompletionItem"/>
+        /// In VS for example, this is the associated VS async completion item.
+        /// </summary>
+        public readonly TEditorCompletionItem EditorCompletionItem;
 
         // We want to preserve the original alphabetical order for items with same pattern match score,
         // but `ArrayBuilder.Sort` we currently use isn't stable. So we have to add a monotonically increasing 
@@ -32,26 +32,27 @@ internal readonly struct MatchResult
         private readonly int _indexInOriginalSortedOrder;
 
         public MatchResult(
-            RoslynCompletionItem roslynCompletionItem, VSCompletionItem vsCompletionItem,
-            bool matchedFilterText, PatternMatch? patternMatch, int index,
-            ImmutableArray<Span> highlightedSpans)
+            RoslynCompletionItem roslynCompletionItem,
+            TEditorCompletionItem editorCompletionItem,
+            bool matchedFilterText,
+            PatternMatch? patternMatch,
+            int index)
         {
             RoslynCompletionItem = roslynCompletionItem;
+            EditorCompletionItem = editorCompletionItem;
             MatchedFilterText = matchedFilterText;
             PatternMatch = patternMatch;
-            VSCompletionItem = vsCompletionItem;
             _indexInOriginalSortedOrder = index;
-            HighlightedSpans = highlightedSpans;
         }
 
-        public static IComparer<MatchResult> SortingComparer => FilterResultSortingComparer.Instance;
+        public static IComparer<MatchResult<TEditorCompletionItem>> SortingComparer => FilterResultSortingComparer.Instance;
 
-        private class FilterResultSortingComparer : IComparer<MatchResult>
+        private class FilterResultSortingComparer : IComparer<MatchResult<TEditorCompletionItem>>
         {
             public static FilterResultSortingComparer Instance { get; } = new FilterResultSortingComparer();
 
             // This comparison is used for sorting items in the completion list for the original sorting.
-            public int Compare(MatchResult x, MatchResult y)
+            public int Compare(MatchResult<TEditorCompletionItem> x, MatchResult<TEditorCompletionItem> y)
             {
                 var matchX = x.PatternMatch;
                 var matchY = y.PatternMatch;
@@ -80,11 +81,11 @@ public int Compare(MatchResult x, MatchResult y)
         }
 
         // This comparison is used in the deletion/backspace scenario for selecting best elements.
-        public int CompareTo(MatchResult other, string filterText)
+        public int CompareTo(MatchResult<TEditorCompletionItem> other, string filterText)
             => ComparerWithState.CompareTo(this, other, filterText, s_comparers);
 
-        private static readonly ImmutableArray<Func<MatchResult, string, IComparable>> s_comparers =
-            ImmutableArray.Create<Func<MatchResult, string, IComparable>>(
+        private static readonly ImmutableArray<Func<MatchResult<TEditorCompletionItem>, string, IComparable>> s_comparers =
+            ImmutableArray.Create<Func<MatchResult<TEditorCompletionItem>, string, IComparable>>(
                 // Prefer the item that matches a longer prefix of the filter text.
                 (f, s) => f.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(s),
                 // If there are "Abc" vs "abc", we should prefer the case typed by user.
diff --git a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ImportCompletionItem.cs b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ImportCompletionItem.cs
index 3d84f2452cce8..7e4e98d481e4c 100644
--- a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ImportCompletionItem.cs
+++ b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ImportCompletionItem.cs
@@ -53,7 +53,7 @@ public static CompletionItem Create(
                 {
                     // We don't need arity to recover symbol if we already have SymbolKeyData or it's 0.
                     // (but it still needed below to decide whether to show generic suffix)
-                    builder.Add(TypeAritySuffixName, AbstractDeclaredSymbolInfoFactoryService.GetMetadataAritySuffix(arity));
+                    builder.Add(TypeAritySuffixName, ArityUtilities.GetMetadataAritySuffix(arity));
                 }
 
                 properties = builder.ToImmutableDictionaryAndFree();
diff --git a/src/Features/Core/Portable/Completion/Utilities.cs b/src/Features/Core/Portable/Completion/Utilities.cs
index e4f9b9b65e3d8..409e6e8a8e305 100644
--- a/src/Features/Core/Portable/Completion/Utilities.cs
+++ b/src/Features/Core/Portable/Completion/Utilities.cs
@@ -38,5 +38,12 @@ public static TextChange Collapse(SourceText newText, ImmutableArray<TextChange>
 
             return new TextChange(totalOldSpan, newText.ToString(totalNewSpan));
         }
+
+        // This is a temporarily method to support preference of IntelliCode items comparing to non-IntelliCode items.
+        // We expect that Editor will introduce this support and we will get rid of relying on the "★" then.
+        // We check both the display text and the display text prefix to account for IntelliCode item providers
+        // that may be using the prefix to include the ★.
+        internal static bool IsPreferredItem(this CompletionItem completionItem)
+            => completionItem.DisplayText.StartsWith("★") || completionItem.DisplayTextPrefix.StartsWith("★");
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/Diagnostics/VisualStudioDiagnosticModeService.cs b/src/Features/Core/Portable/Diagnostics/DefaultDiagnosticModeServiceFactory.cs
similarity index 64%
rename from src/VisualStudio/Core/Def/Implementation/Diagnostics/VisualStudioDiagnosticModeService.cs
rename to src/Features/Core/Portable/Diagnostics/DefaultDiagnosticModeServiceFactory.cs
index f547f08b76b5a..72e287dcb8965 100644
--- a/src/VisualStudio/Core/Def/Implementation/Diagnostics/VisualStudioDiagnosticModeService.cs
+++ b/src/Features/Core/Portable/Diagnostics/DefaultDiagnosticModeServiceFactory.cs
@@ -5,32 +5,31 @@
 using System;
 using System.Collections.Generic;
 using System.Composition;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
 
-namespace Microsoft.VisualStudio.LanguageServices.Implementation.Diagnostics
+namespace Microsoft.CodeAnalysis.Diagnostics
 {
-    [ExportWorkspaceServiceFactory(typeof(IDiagnosticModeService), ServiceLayer.Host), Shared]
-    internal class VisualStudioDiagnosticModeServiceFactory : IWorkspaceServiceFactory
+    [ExportWorkspaceServiceFactory(typeof(IDiagnosticModeService), ServiceLayer.Default), Shared]
+    internal class DefaultDiagnosticModeServiceFactory : IWorkspaceServiceFactory
     {
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public VisualStudioDiagnosticModeServiceFactory()
+        public DefaultDiagnosticModeServiceFactory()
         {
         }
 
         public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
-            => new VisualStudioDiagnosticModeService(workspaceServices.Workspace);
+            => new DefaultDiagnosticModeService(workspaceServices.Workspace);
 
-        private class VisualStudioDiagnosticModeService : IDiagnosticModeService
+        private class DefaultDiagnosticModeService : IDiagnosticModeService
         {
             private readonly Workspace _workspace;
             private readonly Dictionary<Option2<DiagnosticMode>, Lazy<DiagnosticMode>> _optionToMode = new();
 
-            public VisualStudioDiagnosticModeService(Workspace workspace)
+            public DefaultDiagnosticModeService(Workspace workspace)
             {
                 _workspace = workspace;
             }
@@ -65,11 +64,26 @@ private DiagnosticMode ComputeDiagnosticMode(Option2<DiagnosticMode> option)
                 if (inCodeSpacesServer)
                     return DiagnosticMode.Pull;
 
+                var diagnosticModeOption = _workspace.Options.GetOption(option);
+
+                // If the workspace diagnostic mode is set to Default, defer to the feature flag service.
+                if (diagnosticModeOption == DiagnosticMode.Default)
+                {
+                    return GetDiagnosticModeFromFeatureFlag();
+                }
+
                 // Otherwise, defer to the workspace+option to determine what mode we're in.
-                return _workspace.Options.GetOption(option);
+                return diagnosticModeOption;
+            }
+
+            private DiagnosticMode GetDiagnosticModeFromFeatureFlag()
+            {
+                var featureFlagService = _workspace.Services.GetRequiredService<IExperimentationService>();
+                var isPullDiagnosticExperimentEnabled = featureFlagService.IsExperimentEnabled(WellKnownExperimentNames.LspPullDiagnosticsFeatureFlag);
+                return isPullDiagnosticExperimentEnabled ? DiagnosticMode.Pull : DiagnosticMode.Push;
             }
 
-            private bool IsInCodeSpacesServer()
+            private static bool IsInCodeSpacesServer()
             {
                 // hack until there is an officially supported free-threaded synchronous platform API to ask this question.
                 return Environment.GetEnvironmentVariable("VisualStudioServerMode") == "1";
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
index 3d398a1b76fc5..a483dbe3b8649 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
@@ -188,6 +188,52 @@ public ImmutableArray<StateSet> CreateBuildOnlyProjectStateSet(Project project)
                 return stateSets.ToImmutable();
             }
 
+            /// <summary>
+            /// Determines if any of the state sets in <see cref="GetAllHostStateSets()"/> match a specified predicate.
+            /// </summary>
+            /// <remarks>
+            /// This method avoids the performance overhead of calling <see cref="GetAllHostStateSets()"/> for the
+            /// specific case where the result is only used for testing if any element meets certain conditions.
+            /// </remarks>
+            public bool HasAnyHostStateSet<TArg>(Func<StateSet, TArg, bool> match, TArg arg)
+            {
+                foreach (var (_, hostStateSet) in _hostAnalyzerStateMap)
+                {
+                    foreach (var stateSet in hostStateSet.OrderedStateSets)
+                    {
+                        if (match(stateSet, arg))
+                            return true;
+                    }
+                }
+
+                return false;
+            }
+
+            /// <summary>
+            /// Determines if any of the state sets in <see cref="_projectAnalyzerStateMap"/> for a specific project
+            /// match a specified predicate.
+            /// </summary>
+            /// <remarks>
+            /// <para>This method avoids the performance overhead of calling <see cref="GetStateSets(Project)"/> for the
+            /// specific case where the result is only used for testing if any element meets certain conditions.</para>
+            ///
+            /// <para>Note that host state sets (i.e. ones retured by <see cref="GetAllHostStateSets()"/> are not tested
+            /// by this method.</para>
+            /// </remarks>
+            public bool HasAnyProjectStateSet<TArg>(ProjectId projectId, Func<StateSet, TArg, bool> match, TArg arg)
+            {
+                if (_projectAnalyzerStateMap.TryGetValue(projectId, out var entry))
+                {
+                    foreach (var (_, stateSet) in entry.StateSetMap)
+                    {
+                        if (match(stateSet, arg))
+                            return true;
+                    }
+                }
+
+                return false;
+            }
+
             public bool OnProjectRemoved(IEnumerable<StateSet> stateSets, ProjectId projectId)
             {
                 var removed = false;
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
index 1366c6d094351..dfe9aaba981bf 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
@@ -11,7 +11,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeStyle;
-using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -64,17 +63,11 @@ public DiagnosticIncrementalAnalyzer(
 
         internal DiagnosticAnalyzerInfoCache DiagnosticAnalyzerInfoCache => _diagnosticAnalyzerRunner.AnalyzerInfoCache;
 
+        [PerformanceSensitive("https://github.com/dotnet/roslyn/issues/54400", Constraint = "Avoid calling GetAllHostStateSets on this hot path.")]
         public bool ContainsDiagnostics(ProjectId projectId)
         {
-            foreach (var stateSet in _stateManager.GetStateSets(projectId))
-            {
-                if (stateSet.ContainsAnyDocumentOrProjectDiagnostics(projectId))
-                {
-                    return true;
-                }
-            }
-
-            return false;
+            return _stateManager.HasAnyHostStateSet(static (stateSet, arg) => stateSet.ContainsAnyDocumentOrProjectDiagnostics(arg), projectId)
+                || _stateManager.HasAnyProjectStateSet(projectId, static (stateSet, arg) => stateSet.ContainsAnyDocumentOrProjectDiagnostics(arg), projectId);
         }
 
         public bool NeedsReanalysisOnOptionChanged(object sender, OptionChangedEventArgs e)
diff --git a/src/Features/Core/Portable/Diagnostics/IDiagnosticModeService.cs b/src/Features/Core/Portable/Diagnostics/IDiagnosticModeService.cs
index 35b6175278cb6..473a6a3d6cfaa 100644
--- a/src/Features/Core/Portable/Diagnostics/IDiagnosticModeService.cs
+++ b/src/Features/Core/Portable/Diagnostics/IDiagnosticModeService.cs
@@ -2,10 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
-using System.Composition;
 using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
 
 namespace Microsoft.CodeAnalysis.Diagnostics
@@ -19,30 +16,6 @@ internal interface IDiagnosticModeService : IWorkspaceService
         DiagnosticMode GetDiagnosticMode(Option2<DiagnosticMode> diagnosticMode);
     }
 
-    [ExportWorkspaceServiceFactory(typeof(IDiagnosticModeService)), Shared]
-    internal class DefaultDiagnosticModeServiceFactory : IWorkspaceServiceFactory
-    {
-        [ImportingConstructor]
-        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public DefaultDiagnosticModeServiceFactory()
-        {
-        }
-
-        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
-            => new DefaultDiagnosticModeService(workspaceServices.Workspace);
-
-        private class DefaultDiagnosticModeService : IDiagnosticModeService
-        {
-            private readonly Workspace _workspace;
-
-            public DefaultDiagnosticModeService(Workspace workspace)
-                => _workspace = workspace;
-
-            public DiagnosticMode GetDiagnosticMode(Option2<DiagnosticMode> diagnosticMode)
-                => _workspace.Options.GetOption(diagnosticMode);
-        }
-    }
-
     internal static class DiagnosticModeExtensions
     {
         public static DiagnosticMode GetDiagnosticMode(this Workspace workspace, Option2<DiagnosticMode> option)
diff --git a/src/Features/Core/Portable/DocumentationComments/AbstractDocumentationCommentFormattingService.cs b/src/Features/Core/Portable/DocumentationComments/AbstractDocumentationCommentFormattingService.cs
index 3714fea91d5ef..03c637fc424b9 100644
--- a/src/Features/Core/Portable/DocumentationComments/AbstractDocumentationCommentFormattingService.cs
+++ b/src/Features/Core/Portable/DocumentationComments/AbstractDocumentationCommentFormattingService.cs
@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Xml;
 using System.Xml.Linq;
@@ -102,10 +103,14 @@ public void AppendSingleSpace()
             public void AppendString(string s)
             {
                 EmitPendingChars();
-
-                Builder.Add(new TaggedText(TextTags.Text, s, Style, NavigationTarget.target, NavigationTarget.hint));
+                Builder.Add(new TaggedText(TextTags.Text, NormalizeLineEndings(s), Style, NavigationTarget.target, NavigationTarget.hint));
 
                 _anyNonWhitespaceSinceLastPara = true;
+
+                // XText.Value returns a string with `\n` as the line endings, causing
+                // the end result to have mixed line-endings. So normalize everything to `\r\n`.
+                // https://www.w3.org/TR/xml/#sec-line-ends
+                static string NormalizeLineEndings(string input) => input.Replace("\n", "\r\n");
             }
 
             public void AppendParts(IEnumerable<TaggedText> parts)
@@ -305,8 +310,9 @@ public ImmutableArray<TaggedText> Format(string rawXmlText, ISymbol symbol, Sema
 
         private static void AppendTextFromNode(FormatterState state, XNode node, Compilation compilation)
         {
-            if (node.NodeType == XmlNodeType.Text)
+            if (node.NodeType is XmlNodeType.Text or XmlNodeType.CDATA)
             {
+                // cast is safe since XCData inherits XText
                 AppendTextFromTextNode(state, (XText)node);
             }
 
@@ -354,13 +360,16 @@ DocumentationCommentXmlNames.SeeAlsoElementName or
 
                 return;
             }
-            else if (name is DocumentationCommentXmlNames.CElementName
-                or DocumentationCommentXmlNames.CodeElementName
-                or "tt")
+            else if (name is DocumentationCommentXmlNames.CElementName or "tt")
             {
                 needPopStyle = true;
                 state.PushStyle(TaggedTextStyle.Code);
             }
+            else if (name is DocumentationCommentXmlNames.CodeElementName)
+            {
+                needPopStyle = true;
+                state.PushStyle(TaggedTextStyle.Code | TaggedTextStyle.PreserveWhitespace);
+            }
             else if (name is "em" or "i")
             {
                 needPopStyle = true;
@@ -550,6 +559,13 @@ private static string TrimCrefPrefix(string value)
         private static void AppendTextFromTextNode(FormatterState state, XText element)
         {
             var rawText = element.Value;
+            if ((state.Style & TaggedTextStyle.PreserveWhitespace) == TaggedTextStyle.PreserveWhitespace)
+            {
+                // Don't normalize code from middle. Only trim leading/trailing new lines.
+                state.AppendString(rawText.Trim('\n'));
+                return;
+            }
+
             var builder = new StringBuilder(rawText.Length);
 
             // Normalize the whitespace.
diff --git a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
index 81e68f05df5c7..2e20695da1d9a 100644
--- a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
+++ b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
@@ -2485,7 +2485,8 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
                                             // their accessors below.
                                             continue;
                                         }
-                                        else if (IsPropertyAccessorDeclarationMatchingPrimaryConstructorParameter(oldDeclaration, newSymbol.ContainingType, out var isFirst))
+
+                                        if (IsPropertyAccessorDeclarationMatchingPrimaryConstructorParameter(oldDeclaration, newSymbol.ContainingType, out var isFirst))
                                         {
                                             // Defer a constructor edit to cover the property initializer changing
                                             DeferConstructorEdit(oldSymbol.ContainingType, newSymbol.ContainingType, newDeclaration: null, syntaxMap, oldSymbol.IsStatic, ref instanceConstructorEdits, ref staticConstructorEdits);
@@ -2505,10 +2506,11 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
                                             }
                                         }
 
-                                        // can't change visibility:
+                                        // The new symbol is implicitly declared and thus has implied accessibility that needs to be the same
+                                        // as the accessibility of the deleted explicit symbol.
                                         if (newSymbol.DeclaredAccessibility != oldSymbol.DeclaredAccessibility)
                                         {
-                                            ReportDeletedMemberRudeEdit(diagnostics, editScript, oldDeclaration, oldSymbol, RudeEditKind.ChangingVisibility);
+                                            ReportDeletedMemberRudeEdit(diagnostics, editScript, oldDeclaration, oldSymbol, RudeEditKind.ChangingAccessibility);
                                             continue;
                                         }
 
@@ -2594,16 +2596,6 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
 
                                         if (oldSymbol.IsImplicitlyDeclared)
                                         {
-                                            // Replace implicit declaration with an explicit one with a different visibility is a rude edit.
-                                            if (oldSymbol.DeclaredAccessibility != newSymbol.DeclaredAccessibility)
-                                            {
-                                                diagnostics.Add(new RudeEditDiagnostic(RudeEditKind.ChangingVisibility,
-                                                    GetDiagnosticSpan(newDeclaration, edit.Kind),
-                                                    arguments: new[] { GetDisplayName(newDeclaration, edit.Kind) }));
-
-                                                continue;
-                                            }
-
                                             // If a user explicitly implements a member of a record then we want to issue an update, not an insert.
                                             if (oldSymbol.DeclaringSyntaxReferences.Length == 1)
                                             {
@@ -2666,25 +2658,14 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
                                             // if it changed in any way that's not allowed.
                                             ReportDeclarationInsertDeleteRudeEdits(diagnostics, oldDeclaration, newDeclaration, oldSymbol, newSymbol);
 
-                                            // If a node has been inserted but neither old nor new has a body, we can stop processing.
-                                            // The exception to this is explicitly implemented properties that implement positional parameters of
-                                            // records, as even not having an initializer is an "edit", since the compiler generated property would have
-                                            // had one.
-                                            var isRecordPrimaryConstructorParameter = IsRecordPrimaryConstructorParameter(oldDeclaration);
-
                                             var oldBody = TryGetDeclarationBody(oldDeclaration);
-                                            var newBody = TryGetDeclarationBody(newDeclaration);
-                                            if (oldBody == null && newBody == null && !isRecordPrimaryConstructorParameter)
-                                            {
-                                                continue;
-                                            }
-
                                             if (oldBody != null)
                                             {
                                                 // The old symbol's declaration syntax may be located in a different document than the old version of the current document.
                                                 var oldSyntaxDocument = oldProject.Solution.GetRequiredDocument(oldDeclaration.SyntaxTree);
                                                 var oldSyntaxModel = await oldSyntaxDocument.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
                                                 var oldSyntaxText = await oldSyntaxDocument.GetTextAsync(cancellationToken).ConfigureAwait(false);
+                                                var newBody = TryGetDeclarationBody(newDeclaration);
 
                                                 // Skip analysis of active statements. We already report rude edit for removal of code containing
                                                 // active statements in the old declaration and don't currently support moving active statements.
@@ -2711,16 +2692,21 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
                                             // If a constructor changes from including initializers to not including initializers
                                             // we don't need to aggregate syntax map from all initializers for the constructor update semantic edit.
                                             var isNewConstructorWithMemberInitializers = IsConstructorWithMemberInitializers(newDeclaration);
-                                            if (isNewConstructorWithMemberInitializers ||
-                                                IsDeclarationWithInitializer(oldDeclaration) ||
-                                                IsDeclarationWithInitializer(newDeclaration) ||
-                                                isRecordPrimaryConstructorParameter)
+                                            var isDeclarationWithInitializer = IsDeclarationWithInitializer(oldDeclaration) || IsDeclarationWithInitializer(newDeclaration);
+                                            var isRecordPrimaryConstructorParameter = IsRecordPrimaryConstructorParameter(oldDeclaration);
+
+                                            if (isNewConstructorWithMemberInitializers || isDeclarationWithInitializer || isRecordPrimaryConstructorParameter)
                                             {
                                                 if (isNewConstructorWithMemberInitializers)
                                                 {
                                                     processedSymbols.Remove(newSymbol);
                                                 }
 
+                                                if (isDeclarationWithInitializer)
+                                                {
+                                                    AnalyzeSymbolUpdate(oldSymbol, newSymbol, newDeclaration, capabilities, diagnostics, semanticEdits, syntaxMap, cancellationToken);
+                                                }
+
                                                 DeferConstructorEdit(oldSymbol.ContainingType, newSymbol.ContainingType, newDeclaration, syntaxMap, newSymbol.IsStatic, ref instanceConstructorEdits, ref staticConstructorEdits);
 
                                                 // Don't add a separate semantic edit.
@@ -2888,18 +2874,19 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
                                     // If a constructor changes from including initializers to not including initializers
                                     // we don't need to aggregate syntax map from all initializers for the constructor update semantic edit.
                                     var isConstructorWithMemberInitializers = IsConstructorWithMemberInitializers(newDeclaration);
+                                    var isDeclarationWithInitializer = IsDeclarationWithInitializer(oldDeclaration) || IsDeclarationWithInitializer(newDeclaration);
 
-                                    if (isConstructorWithMemberInitializers ||
-                                        IsDeclarationWithInitializer(oldDeclaration) ||
-                                        IsDeclarationWithInitializer(newDeclaration))
+                                    if (isConstructorWithMemberInitializers || isDeclarationWithInitializer)
                                     {
                                         if (isConstructorWithMemberInitializers)
                                         {
                                             processedSymbols.Remove(newSymbol);
                                         }
 
-                                        // Need to check for attribute rude edits for fields and properties
-                                        AnalyzeCustomAttributes(oldSymbol, newSymbol, capabilities, diagnostics, semanticEdits, syntaxMap, cancellationToken);
+                                        if (isDeclarationWithInitializer)
+                                        {
+                                            AnalyzeSymbolUpdate(oldSymbol, newSymbol, newDeclaration, capabilities, diagnostics, semanticEdits, syntaxMap, cancellationToken);
+                                        }
 
                                         DeferConstructorEdit(oldSymbol.ContainingType, newSymbol.ContainingType, newDeclaration, syntaxMap, newSymbol.IsStatic, ref instanceConstructorEdits, ref staticConstructorEdits);
 
@@ -2919,7 +2906,9 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
 
                         if (editKind == SemanticEditKind.Update)
                         {
-                            AnalyzeCustomAttributes(oldSymbol, newSymbol, capabilities, diagnostics, semanticEdits, syntaxMap, cancellationToken);
+                            Contract.ThrowIfNull(oldSymbol);
+
+                            AnalyzeSymbolUpdate(oldSymbol, newSymbol, newDeclaration, capabilities, diagnostics, semanticEdits, syntaxMap, cancellationToken);
 
                             // The only update to the type itself that's supported is an addition or removal of the partial modifier,
                             // which does not have impact on the emitted type metadata.
@@ -2928,9 +2917,9 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
                                 continue;
                             }
 
-                            // The field/property itself is being updated. Currently we do not allow any modifiers to be updated. Attribute
-                            // updates will have been handled already
-                            if (newSymbol is IFieldSymbol or IPropertySymbol)
+                            // The field/property/event itself is being updated. Currently we do not allow any modifiers to be updated.
+                            // Attribute updates will have been handled already.
+                            if (newSymbol is IFieldSymbol or IPropertySymbol or IEventSymbol)
                             {
                                 continue;
                             }
@@ -2988,7 +2977,9 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
                         Contract.ThrowIfFalse(IsDeclarationWithInitializer(oldDeclaration) == IsDeclarationWithInitializer(newDeclaration));
 
                         var isConstructorWithMemberInitializers = IsConstructorWithMemberInitializers(newDeclaration);
-                        if (isConstructorWithMemberInitializers || IsDeclarationWithInitializer(newDeclaration))
+                        var isDeclarationWithInitializer = IsDeclarationWithInitializer(newDeclaration);
+
+                        if (isConstructorWithMemberInitializers || isDeclarationWithInitializer)
                         {
                             // TODO: only create syntax map if any field initializers are active/contain lambdas or this is a partial type
                             syntaxMap ??= CreateSyntaxMapForEquivalentNodes(oldDeclaration, newDeclaration);
@@ -3020,6 +3011,7 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
                         oldModel,
                         oldCompilation,
                         processedSymbols,
+                        capabilities,
                         isStatic: false,
                         semanticEdits,
                         diagnostics,
@@ -3034,6 +3026,7 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
                         oldModel,
                         oldCompilation,
                         processedSymbols,
+                        capabilities,
                         isStatic: true,
                         semanticEdits,
                         diagnostics,
@@ -3062,7 +3055,111 @@ private async Task<ImmutableArray<SemanticEditInfo>> AnalyzeSemanticsAsync(
             }
         }
 
-        private void AnalyzeCustomAttributes(ISymbol? oldSymbol, ISymbol newSymbol, EditAndContinueCapabilities capabilities, ArrayBuilder<RudeEditDiagnostic> diagnostics, ArrayBuilder<SemanticEditInfo>? semanticEdits, Func<SyntaxNode, SyntaxNode?>? syntaxMap, CancellationToken cancellationToken)
+        private void ReportUpdatedSymbolDeclarationRudeEdits(ArrayBuilder<RudeEditDiagnostic> diagnostics, ISymbol oldSymbol, ISymbol newSymbol, SyntaxNode newDeclaration)
+        {
+            var rudeEdit = RudeEditKind.None;
+
+            if (oldSymbol.DeclaredAccessibility != newSymbol.DeclaredAccessibility)
+            {
+                rudeEdit = RudeEditKind.ChangingAccessibility;
+            }
+
+            if (oldSymbol.IsStatic != newSymbol.IsStatic ||
+                oldSymbol.IsVirtual != newSymbol.IsVirtual ||
+                oldSymbol.IsAbstract != newSymbol.IsAbstract ||
+                oldSymbol.IsOverride != newSymbol.IsOverride)
+            {
+                // Do not report for accessors as the error will be reported on their associated symbol.
+                if (oldSymbol is not IMethodSymbol { AssociatedSymbol: not null })
+                {
+                    rudeEdit = RudeEditKind.ModifiersUpdate;
+                }
+            }
+
+            if (oldSymbol is IFieldSymbol oldField && newSymbol is IFieldSymbol newField)
+            {
+                if (oldField.IsConst != newField.IsConst ||
+                    oldField.IsReadOnly != newField.IsReadOnly ||
+                    oldField.IsVolatile != newField.IsVolatile)
+                {
+                    rudeEdit = RudeEditKind.ModifiersUpdate;
+                }
+            }
+            else if (oldSymbol is IMethodSymbol oldMethod && newSymbol is IMethodSymbol newMethod)
+            {
+                if (oldMethod.IsReadOnly != newMethod.IsReadOnly)
+                {
+                    rudeEdit = RudeEditKind.ModifiersUpdate;
+                }
+            }
+            else if (oldSymbol is INamedTypeSymbol oldType && newSymbol is INamedTypeSymbol newType)
+            {
+                if (oldType.TypeKind != newType.TypeKind ||
+                    oldType.IsRecord != newType.IsRecord) // TODO: https://github.com/dotnet/roslyn/issues/51874
+                {
+                    rudeEdit = RudeEditKind.TypeKindUpdate;
+                }
+                else if (oldType.IsRefLikeType != newType.IsRefLikeType ||
+                         oldType.IsReadOnly != newType.IsReadOnly)
+                {
+                    rudeEdit = RudeEditKind.ModifiersUpdate;
+                }
+            }
+            else if (oldSymbol is IEventSymbol { AddMethod: not null, RemoveMethod: not null } oldEvent &&
+                     newSymbol is IEventSymbol { AddMethod: not null, RemoveMethod: not null } newEvent)
+            {
+                // "readonly" modifier can only be applied on the event itself, not on its accessors.
+                if (oldEvent.AddMethod.IsReadOnly != newEvent.AddMethod.IsReadOnly ||
+                    oldEvent.RemoveMethod.IsReadOnly != newEvent.RemoveMethod.IsReadOnly)
+                {
+                    rudeEdit = RudeEditKind.ModifiersUpdate;
+                }
+            }
+
+            // Do not report modifier update if type kind changed.
+            if (rudeEdit == RudeEditKind.None && oldSymbol.IsSealed != newSymbol.IsSealed)
+            {
+                // Do not report for accessors as the error will be reported on their associated symbol.
+                if (oldSymbol is not IMethodSymbol { AssociatedSymbol: not null })
+                {
+                    rudeEdit = RudeEditKind.ModifiersUpdate;
+                }
+            }
+
+            if (rudeEdit != RudeEditKind.None)
+            {
+                var arguments = rudeEdit switch
+                {
+                    RudeEditKind.TypeKindUpdate => Array.Empty<string>(),
+                    _ => new[] { GetDisplayName(newDeclaration, EditKind.Update) }
+                };
+
+                diagnostics.Add(new RudeEditDiagnostic(rudeEdit, GetDiagnosticSpan(newDeclaration, EditKind.Update), arguments: arguments));
+            }
+        }
+
+        private void AnalyzeSymbolUpdate(
+            ISymbol oldSymbol,
+            ISymbol newSymbol,
+            SyntaxNode? newDeclaration,
+            EditAndContinueCapabilities capabilities,
+            ArrayBuilder<RudeEditDiagnostic> diagnostics,
+            ArrayBuilder<SemanticEditInfo>? semanticEdits,
+            Func<SyntaxNode, SyntaxNode?>? syntaxMap,
+            CancellationToken cancellationToken)
+        {
+            Contract.ThrowIfFalse(newSymbol.IsImplicitlyDeclared == newDeclaration is null);
+
+            AnalyzeCustomAttributes(oldSymbol, newSymbol, capabilities, diagnostics, semanticEdits, syntaxMap, cancellationToken);
+
+            // We might be updating an explicit old declaration to an implicit new declaration.
+            if (newDeclaration != null)
+            {
+                ReportUpdatedSymbolDeclarationRudeEdits(diagnostics, oldSymbol, newSymbol, newDeclaration);
+            }
+        }
+
+        private void AnalyzeCustomAttributes(ISymbol oldSymbol, ISymbol newSymbol, EditAndContinueCapabilities capabilities, ArrayBuilder<RudeEditDiagnostic> diagnostics, ArrayBuilder<SemanticEditInfo>? semanticEdits, Func<SyntaxNode, SyntaxNode?>? syntaxMap, CancellationToken cancellationToken)
         {
             var needsEdit = false;
 
@@ -3077,26 +3174,30 @@ private void AnalyzeCustomAttributes(ISymbol? oldSymbol, ISymbol newSymbol, Edit
             }
             else if (newSymbol is INamedTypeSymbol { DelegateInvokeMethod: not null } newType)
             {
-                var oldType = oldSymbol as INamedTypeSymbol;
+                if (oldSymbol is not INamedTypeSymbol { DelegateInvokeMethod: not null } oldType)
+                {
+                    return;
+                }
+
                 // If this is a delegate with attributes on its return type for example, they are found on the DelegateInvokeMethod
-                AnalyzeCustomAttributes(oldType?.DelegateInvokeMethod, newType.DelegateInvokeMethod, capabilities, diagnostics, semanticEdits, syntaxMap, cancellationToken);
+                AnalyzeCustomAttributes(oldType.DelegateInvokeMethod, newType.DelegateInvokeMethod, capabilities, diagnostics, semanticEdits, syntaxMap, cancellationToken);
             }
 
             foreach (var parameter in newSymbol.GetParameters())
             {
-                var oldParameter = oldSymbol?.GetParameters().FirstOrDefault(p => p.Name.Equals(parameter.Name));
+                var oldParameter = oldSymbol.GetParameters().FirstOrDefault(p => p.Name.Equals(parameter.Name));
                 needsEdit |= HasCustomAttributeChanges(oldParameter?.GetAttributes(), parameter.GetAttributes(), parameter, capabilities, diagnostics);
             }
 
             foreach (var typeParam in newSymbol.GetTypeParameters())
             {
-                var oldParameter = oldSymbol?.GetTypeParameters().FirstOrDefault(p => p.Name.Equals(typeParam.Name));
+                var oldParameter = oldSymbol.GetTypeParameters().FirstOrDefault(p => p.Name.Equals(typeParam.Name));
                 needsEdit |= HasCustomAttributeChanges(oldParameter?.GetAttributes(), typeParam.GetAttributes(), typeParam, capabilities, diagnostics);
             }
 
             // This is the only case we care about whether to issue an edit or not, because this is the only case where types have their attributes checked
             // and types are the only things that would otherwise not have edits reported.
-            needsEdit |= HasCustomAttributeChanges(oldSymbol?.GetAttributes(), newSymbol.GetAttributes(), newSymbol, capabilities, diagnostics);
+            needsEdit |= HasCustomAttributeChanges(oldSymbol.GetAttributes(), newSymbol.GetAttributes(), newSymbol, capabilities, diagnostics);
 
             // If we don't need to add an edit, then we're done
             if (!needsEdit || semanticEdits is null)
@@ -3105,7 +3206,7 @@ private void AnalyzeCustomAttributes(ISymbol? oldSymbol, ISymbol newSymbol, Edit
             }
 
             // Most symbol types will automatically have an edit added, so we just need to handle a few
-            if (newSymbol is INamedTypeSymbol or IFieldSymbol or IPropertySymbol)
+            if (newSymbol is INamedTypeSymbol or IFieldSymbol or IPropertySymbol or IEventSymbol)
             {
                 var symbolKey = SymbolKey.Create(newSymbol, cancellationToken);
                 semanticEdits.Add(new SemanticEditInfo(SemanticEditKind.Update, symbolKey, syntaxMap, syntaxMapTree: null, partialType: null));
@@ -3179,6 +3280,7 @@ static void FindChangedAttributes(ImmutableArray<AttributeData>? oldAttributes,
                         }
                     }
                 }
+
                 return null;
             }
 
@@ -3533,6 +3635,7 @@ private void AddConstructorEdits(
             SemanticModel? oldModel,
             Compilation oldCompilation,
             IReadOnlySet<ISymbol> processedSymbols,
+            EditAndContinueCapabilities capabilities,
             bool isStatic,
             [Out] ArrayBuilder<SemanticEditInfo> semanticEdits,
             [Out] ArrayBuilder<RudeEditDiagnostic> diagnostics,
@@ -3581,49 +3684,45 @@ static bool IsNotInDocument(SyntaxReference reference, SyntaxTree syntaxTree)
 
                     var syntaxMapToUse = aggregateSyntaxMap;
 
+                    SyntaxNode? newDeclaration = null;
                     ISymbol? oldCtor;
                     if (!newCtor.IsImplicitlyDeclared)
                     {
                         // Constructors have to have a single declaration syntax, they can't be partial
-                        var newDeclaration = GetSymbolDeclarationSyntax(newCtor.DeclaringSyntaxReferences.Single(), cancellationToken);
+                        newDeclaration = GetSymbolDeclarationSyntax(newCtor.DeclaringSyntaxReferences.Single(), cancellationToken);
+
+                        // Implicit record constructors are represented by the record declaration itself.
+                        // https://github.com/dotnet/roslyn/issues/54403
+                        var isPrimaryRecordConstructor = IsRecordDeclaration(newDeclaration);
 
-                        // Compiler generated constructors of records are not implicitly declared, since they
-                        // points to the actual record declaration. We want to skip these checks because we can't
-                        // reason about initializers for them.
-                        if (!IsRecordDeclaration(newDeclaration))
+                        // Constructor that doesn't contain initializers had a corresponding semantic edit produced previously 
+                        // or was not edited. In either case we should not produce a semantic edit for it.
+                        if (!isPrimaryRecordConstructor && !IsConstructorWithMemberInitializers(newDeclaration))
                         {
-                            // Constructor that doesn't contain initializers had a corresponding semantic edit produced previously 
-                            // or was not edited. In either case we should not produce a semantic edit for it.
-                            if (!IsConstructorWithMemberInitializers(newDeclaration))
-                            {
-                                continue;
-                            }
+                            continue;
+                        }
 
-                            // If no initializer updates were made in the type we only need to produce semantic edits for constructors
-                            // whose body has been updated, otherwise we need to produce edits for all constructors that include initializers.
-                            // If changes were made to initializers or constructors of a partial type in another document they will be merged
-                            // when aggregating semantic edits from all changed documents. Rude edits resulting from those changes, if any, will
-                            // be reported in the document they were made in.
-                            if (!anyInitializerUpdatesInCurrentDocument && !updatesInCurrentDocument.ChangedDeclarations.ContainsKey(newDeclaration))
-                            {
-                                continue;
-                            }
+                        // If no initializer updates were made in the type we only need to produce semantic edits for constructors
+                        // whose body has been updated, otherwise we need to produce edits for all constructors that include initializers.
+                        // If changes were made to initializers or constructors of a partial type in another document they will be merged
+                        // when aggregating semantic edits from all changed documents. Rude edits resulting from those changes, if any, will
+                        // be reported in the document they were made in.
+                        if (!isPrimaryRecordConstructor && !anyInitializerUpdatesInCurrentDocument && !updatesInCurrentDocument.ChangedDeclarations.ContainsKey(newDeclaration))
+                        {
+                            continue;
                         }
 
                         // To avoid costly SymbolKey resolution we first try to match the constructor in the current document
                         // and special case parameter-less constructor.
 
-                        // In the case of records, newDeclaration will point to the record declaration, and hence this
-                        // actually finds the old record declaration, but that is actually sufficient for our needs, as all
-                        // we're using it for is detecting an update, and any changes to the standard record constructors must
-                        // be an update by definition.
-                        if (topMatch.TryGetOldNode(newDeclaration, out var oldDeclaration))
+                        // In the case of records, newDeclaration will point to the record declaration, take the slow path.
+                        if (!isPrimaryRecordConstructor && topMatch.TryGetOldNode(newDeclaration, out var oldDeclaration))
                         {
                             Contract.ThrowIfNull(oldModel);
                             oldCtor = oldModel.GetDeclaredSymbol(oldDeclaration, cancellationToken);
-                            Contract.ThrowIfNull(oldCtor);
+                            Contract.ThrowIfFalse(oldCtor is IMethodSymbol { MethodKind: MethodKind.Constructor or MethodKind.StaticConstructor });
                         }
-                        else if (newCtor.Parameters.Length == 0)
+                        else if (!isPrimaryRecordConstructor && newCtor.Parameters.Length == 0)
                         {
                             oldCtor = TryGetParameterlessConstructor(oldType, isStatic);
                         }
@@ -3661,7 +3760,7 @@ static bool IsNotInDocument(SyntaxReference reference, SyntaxTree syntaxTree)
                         // When explicitly implementing the copy constructor of a record the parameter name must match for symbol matching to work
                         // TODO: Remove this requirement with https://github.com/dotnet/roslyn/issues/52563
                         if (oldCtor != null &&
-                            !IsRecordDeclaration(newDeclaration) &&
+                            !isPrimaryRecordConstructor &&
                             oldCtor.DeclaringSyntaxReferences.Length == 0 &&
                             newCtor.Parameters.Length == 1 &&
                             newType.IsRecord &&
@@ -3718,6 +3817,8 @@ static bool IsNotInDocument(SyntaxReference reference, SyntaxTree syntaxTree)
 
                     if (oldCtor != null)
                     {
+                        AnalyzeSymbolUpdate(oldCtor, newCtor, newDeclaration, capabilities, diagnostics, semanticEdits: null, syntaxMap: null, cancellationToken);
+
                         semanticEdits.Add(new SemanticEditInfo(
                             SemanticEditKind.Update,
                             newCtorKey,
diff --git a/src/Features/Core/Portable/EditAndContinue/ActiveStatementsMap.cs b/src/Features/Core/Portable/EditAndContinue/ActiveStatementsMap.cs
index 8c72c5ce9ce97..f3ca5140cfa6c 100644
--- a/src/Features/Core/Portable/EditAndContinue/ActiveStatementsMap.cs
+++ b/src/Features/Core/Portable/EditAndContinue/ActiveStatementsMap.cs
@@ -180,8 +180,11 @@ void AddStatement(LinePositionSpan unmappedLineSpan, ActiveStatement activeState
             }
 
             var hasAnyLineDirectives = false;
-            foreach (var (unmappedSection, mappedSection) in oldTree.GetLineMappings(cancellationToken))
+            foreach (var lineMapping in oldTree.GetLineMappings(cancellationToken))
             {
+                var unmappedSection = lineMapping.Span;
+                var mappedSection = lineMapping.MappedSpan;
+
                 hasAnyLineDirectives = true;
 
                 var targetPath = mappedSection.HasMappedPath ? mappedSection.Path : oldTree.FilePath;
diff --git a/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs b/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs
index 42cba97deb7bb..089e2da7d7b03 100644
--- a/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs
+++ b/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs
@@ -328,7 +328,7 @@ public Task OnSourceFileUpdatedAsync(Document document, CancellationToken cancel
 
                 var debugInfoReader = debugInfoReaderProvider.CreateEditAndContinueMethodDebugInfoReader();
 
-                var documentTasks = project.State.DocumentStates.States.Select(async documentState =>
+                var documentTasks = project.State.DocumentStates.States.Values.Select(async documentState =>
                 {
                     cancellationToken.ThrowIfCancellationRequested();
 
diff --git a/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs b/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs
index 32c79d77a897f..1029bfd4204c2 100644
--- a/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs
+++ b/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs
@@ -109,7 +109,7 @@ void AddGeneralDiagnostic(EditAndContinueErrorCode code, string resourceName, Di
             AddRudeEdit(RudeEditKind.StackAllocUpdate, nameof(FeaturesResources.Modifying_0_which_contains_the_stackalloc_operator_will_prevent_the_debug_session_from_continuing));
             AddRudeEdit(RudeEditKind.ExperimentalFeaturesEnabled, nameof(FeaturesResources.Modifying_source_with_experimental_language_features_enabled_will_prevent_the_debug_session_from_continuing));
             AddRudeEdit(RudeEditKind.AwaitStatementUpdate, nameof(FeaturesResources.Updating_a_complex_statement_containing_an_await_expression_will_prevent_the_debug_session_from_continuing));
-            AddRudeEdit(RudeEditKind.ChangingVisibility, nameof(FeaturesResources.Changing_visibility_of_0_will_prevent_the_debug_session_from_continuing));
+            AddRudeEdit(RudeEditKind.ChangingAccessibility, nameof(FeaturesResources.Changing_visibility_of_0_will_prevent_the_debug_session_from_continuing));
             AddRudeEdit(RudeEditKind.CapturingVariable, nameof(FeaturesResources.Capturing_variable_0_that_hasn_t_been_captured_before_will_prevent_the_debug_session_from_continuing));
             AddRudeEdit(RudeEditKind.NotCapturingVariable, nameof(FeaturesResources.Ceasing_to_capture_variable_0_will_prevent_the_debug_session_from_continuing));
             AddRudeEdit(RudeEditKind.DeletingCapturedVariable, nameof(FeaturesResources.Deleting_captured_variable_0_will_prevent_the_debug_session_from_continuing));
diff --git a/src/Features/Core/Portable/EditAndContinue/EditAndContinueWorkspaceService.cs b/src/Features/Core/Portable/EditAndContinue/EditAndContinueWorkspaceService.cs
index 06459d0085077..a2970db04abf6 100644
--- a/src/Features/Core/Portable/EditAndContinue/EditAndContinueWorkspaceService.cs
+++ b/src/Features/Core/Portable/EditAndContinue/EditAndContinueWorkspaceService.cs
@@ -97,7 +97,7 @@ public void OnSourceFileUpdated(Document document)
             foreach (var debuggingSession in GetActiveDebuggingSessions())
             {
                 // fire and forget
-                _ = Task.Run(() => debuggingSession.OnSourceFileUpdatedAsync(document));
+                _ = Task.Run(() => debuggingSession.OnSourceFileUpdatedAsync(document)).ReportNonFatalErrorAsync();
             }
         }
 
diff --git a/src/Features/Core/Portable/EditAndContinue/EditSession.cs b/src/Features/Core/Portable/EditAndContinue/EditSession.cs
index b58a6cb1d55ad..2511afe8fbf26 100644
--- a/src/Features/Core/Portable/EditAndContinue/EditSession.cs
+++ b/src/Features/Core/Portable/EditAndContinue/EditSession.cs
@@ -740,7 +740,6 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                     {
                         Contract.ThrowIfNull(emitResult.Baseline);
 
-                        // TODO: Pass these to ManagedModuleUpdate in the new debugger contracts API
                         var updatedMethodTokens = emitResult.UpdatedMethods.SelectAsArray(h => MetadataTokens.GetToken(h));
                         var updatedTypeTokens = emitResult.UpdatedTypes.SelectAsArray(h => MetadataTokens.GetToken(h));
 
@@ -762,7 +761,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                             pdbStream.ToImmutableArray(),
                             projectChanges.LineChanges,
                             updatedMethodTokens,
-                            updatedTypes: ImmutableArray<int>.Empty,
+                            updatedTypeTokens,
                             activeStatementsInUpdatedMethods,
                             exceptionRegionUpdates));
 
diff --git a/src/Features/Core/Portable/EditAndContinue/RudeEditKind.cs b/src/Features/Core/Portable/EditAndContinue/RudeEditKind.cs
index 98c571f9c6802..bd26ddb8f6edd 100644
--- a/src/Features/Core/Portable/EditAndContinue/RudeEditKind.cs
+++ b/src/Features/Core/Portable/EditAndContinue/RudeEditKind.cs
@@ -62,7 +62,7 @@ internal enum RudeEditKind : ushort
         ExperimentalFeaturesEnabled = 45,
 
         AwaitStatementUpdate = 46,
-        ChangingVisibility = 47,
+        ChangingAccessibility = 47,
 
         CapturingVariable = 48,
         NotCapturingVariable = 49,
diff --git a/src/Features/Core/Portable/ExternalAccess/IntelliCode/Api/IntelliCodeCompletionOptions.cs b/src/Features/Core/Portable/ExternalAccess/IntelliCode/Api/IntelliCodeCompletionOptions.cs
new file mode 100644
index 0000000000000..fe59bf815df21
--- /dev/null
+++ b/src/Features/Core/Portable/ExternalAccess/IntelliCode/Api/IntelliCodeCompletionOptions.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.IntelliCode.Api
+{
+    internal static class IntelliCodeCompletionOptions
+    {
+        public static PerLanguageOption<bool> TriggerOnTyping { get; } = (PerLanguageOption<bool>)CompletionOptions.TriggerOnTyping;
+
+        public static PerLanguageOption<bool> TriggerOnTypingLetters { get; } = (PerLanguageOption<bool>)CompletionOptions.TriggerOnTypingLetters2;
+    }
+}
diff --git a/src/Features/Core/Portable/ExternalAccess/UnitTesting/API/UnitTestingHotReloadService.cs b/src/Features/Core/Portable/ExternalAccess/UnitTesting/API/UnitTestingHotReloadService.cs
index c4dd30b3a6994..fdc128d2512ab 100644
--- a/src/Features/Core/Portable/ExternalAccess/UnitTesting/API/UnitTestingHotReloadService.cs
+++ b/src/Features/Core/Portable/ExternalAccess/UnitTesting/API/UnitTestingHotReloadService.cs
@@ -19,7 +19,12 @@ internal sealed class UnitTestingHotReloadService
     {
         private sealed class DebuggerService : IManagedEditAndContinueDebuggerService
         {
-            public static readonly DebuggerService Instance = new();
+            private readonly ImmutableArray<string> _capabilities;
+
+            public DebuggerService(ImmutableArray<string> capabilities)
+            {
+                _capabilities = capabilities;
+            }
 
             public Task<ImmutableArray<ManagedActiveStatementDebugInfo>> GetActiveStatementsAsync(CancellationToken cancellationToken)
                 => Task.FromResult(ImmutableArray<ManagedActiveStatementDebugInfo>.Empty);
@@ -27,9 +32,8 @@ public Task<ImmutableArray<ManagedActiveStatementDebugInfo>> GetActiveStatements
             public Task<ManagedEditAndContinueAvailability> GetAvailabilityAsync(Guid module, CancellationToken cancellationToken)
                 => Task.FromResult(new ManagedEditAndContinueAvailability(ManagedEditAndContinueAvailabilityStatus.Available));
 
-            // TODO: get capabilities from the runtime
             public Task<ImmutableArray<string>> GetCapabilitiesAsync(CancellationToken cancellationToken)
-                => Task.FromResult(ImmutableArray.Create("Baseline", "AddDefinitionToExistingType", "NewTypeDefinition"));
+                => Task.FromResult(_capabilities);
 
             public Task PrepareModuleForUpdateAsync(Guid module, CancellationToken cancellationToken)
                 => Task.CompletedTask;
@@ -64,24 +68,27 @@ public UnitTestingHotReloadService(HostWorkspaceServices services)
         /// Starts the watcher.
         /// </summary>
         /// <param name="solution">Solution that represents sources that match the built binaries on disk.</param>
+        /// <param name="capabilities">Array of capabilities retrieved from the runtime to dictate supported rude edits.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
-        public async Task StartSessionAsync(Solution solution, CancellationToken cancellationToken)
+        public async Task StartSessionAsync(Solution solution, ImmutableArray<string> capabilities, CancellationToken cancellationToken)
         {
-            var newSessionId = await _encService.StartDebuggingSessionAsync(solution, DebuggerService.Instance, captureMatchingDocuments: true, reportDiagnostics: false, cancellationToken).ConfigureAwait(false);
+            var newSessionId = await _encService.StartDebuggingSessionAsync(solution, new DebuggerService(capabilities), captureMatchingDocuments: true, reportDiagnostics: false, cancellationToken).ConfigureAwait(false);
             Contract.ThrowIfFalse(_sessionId == default, "Session already started");
             _sessionId = newSessionId;
         }
 
         /// <summary>
-        /// Emits updates for all projects that differ between the given <paramref name="solution"/> snapshot and the one given to the previous successful call or 
-        /// the one passed to <see cref="StartSessionAsync(Solution, CancellationToken)"/> for the first invocation.
+        /// Emits updates for all projects that differ between the given <paramref name="solution"/> snapshot and the one given to the previous successful call 
+        /// where <paramref name="commitUpdates"/> was `true` or the one passed to <see cref="StartSessionAsync(Solution, ImmutableArray{string}, CancellationToken)"/>
+        /// for the first invocation.
         /// </summary>
         /// <param name="solution">Solution snapshot.</param>
+        /// <param name="commitUpdates">commits changes if true, discards if false</param>
         /// <param name="cancellationToken">Cancellation token.</param>
         /// <returns>
         /// Updates (one for each changed project) and Rude Edit diagnostics. Does not include syntax or semantic diagnostics.
         /// </returns>
-        public async Task<(ImmutableArray<Update> updates, ImmutableArray<Diagnostic> diagnostics)> EmitSolutionUpdateAsync(Solution solution, CancellationToken cancellationToken)
+        public async Task<(ImmutableArray<Update> updates, ImmutableArray<Diagnostic> diagnostics)> EmitSolutionUpdateAsync(Solution solution, bool commitUpdates, CancellationToken cancellationToken)
         {
             var sessionId = _sessionId;
             Contract.ThrowIfFalse(sessionId != default, "Session has not started");
@@ -90,7 +97,14 @@ public async Task StartSessionAsync(Solution solution, CancellationToken cancell
 
             if (results.ModuleUpdates.Status == ManagedModuleUpdateStatus.Ready)
             {
-                _encService.CommitSolutionUpdate(sessionId, out _);
+                if (commitUpdates)
+                {
+                    _encService.CommitSolutionUpdate(sessionId, out _);
+                }
+                else
+                {
+                    _encService.DiscardSolutionUpdate(sessionId);
+                }
             }
 
             var updates = results.ModuleUpdates.Updates.SelectAsArray(
diff --git a/src/Features/Core/Portable/ExternalAccess/Watch/Api/WatchHotReloadService.cs b/src/Features/Core/Portable/ExternalAccess/Watch/Api/WatchHotReloadService.cs
index c8148eb835f3e..1badd4a005f6f 100644
--- a/src/Features/Core/Portable/ExternalAccess/Watch/Api/WatchHotReloadService.cs
+++ b/src/Features/Core/Portable/ExternalAccess/Watch/Api/WatchHotReloadService.cs
@@ -41,13 +41,15 @@ public readonly struct Update
             public readonly ImmutableArray<byte> ILDelta;
             public readonly ImmutableArray<byte> MetadataDelta;
             public readonly ImmutableArray<byte> PdbDelta;
+            public readonly ImmutableArray<int> UpdatedTypes;
 
-            public Update(Guid moduleId, ImmutableArray<byte> ilDelta, ImmutableArray<byte> metadataDelta, ImmutableArray<byte> pdbDelta)
+            public Update(Guid moduleId, ImmutableArray<byte> ilDelta, ImmutableArray<byte> metadataDelta, ImmutableArray<byte> pdbDelta, ImmutableArray<int> updatedTypes)
             {
                 ModuleId = moduleId;
                 ILDelta = ilDelta;
                 MetadataDelta = metadataDelta;
                 PdbDelta = pdbDelta;
+                UpdatedTypes = updatedTypes;
             }
         }
 
@@ -94,7 +96,7 @@ public async Task StartSessionAsync(Solution solution, CancellationToken cancell
             }
 
             var updates = results.ModuleUpdates.Updates.SelectAsArray(
-                update => new Update(update.Module, update.ILDelta, update.MetadataDelta, update.PdbDelta));
+                update => new Update(update.Module, update.ILDelta, update.MetadataDelta, update.PdbDelta, update.UpdatedTypes));
 
             var diagnostics = await results.GetAllDiagnosticsAsync(solution, cancellationToken).ConfigureAwait(false);
 
diff --git a/src/Features/Core/Portable/FindUsages/DefinitionItem.cs b/src/Features/Core/Portable/FindUsages/DefinitionItem.cs
index 95640414d3ea6..c12672789b0ea 100644
--- a/src/Features/Core/Portable/FindUsages/DefinitionItem.cs
+++ b/src/Features/Core/Portable/FindUsages/DefinitionItem.cs
@@ -117,8 +117,8 @@ protected DefinitionItem(
             ImmutableArray<TaggedText> originationParts,
             ImmutableArray<DocumentSpan> sourceSpans,
             ImmutableDictionary<string, string> properties,
-            bool displayIfNoReferences) :
-            this(
+            bool displayIfNoReferences)
+            : this(
                 tags,
                 displayParts,
                 nameDisplayParts,
diff --git a/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction.cs b/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction.cs
index 7d1ba6154ece9..8d308dfc95efa 100644
--- a/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction.cs
+++ b/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction.cs
@@ -309,7 +309,9 @@ private ISymbol GenerateMember(
                 var generateInvisibleMember = GenerateInvisibleMember(member, memberName);
                 memberName = generateInvisibleMember ? member.Name : memberName;
 
-                var generateAbstractly = !generateInvisibleMember && Abstractly;
+                // The language doesn't allow static abstract implementations of interface methods. i.e,
+                // Only interface member is declared abstract static, but implementation should be only static.
+                var generateAbstractly = !member.IsStatic && !generateInvisibleMember && Abstractly;
 
                 // Check if we need to add 'new' to the signature we're adding.  We only need to do this
                 // if we're not generating something explicit and we have a naming conflict with
@@ -393,7 +395,7 @@ private ISymbol GenerateMember(
                 ImplementTypePropertyGenerationBehavior propertyGenerationBehavior)
             {
                 var factory = Document.GetLanguageService<SyntaxGenerator>();
-                var modifiers = new DeclarationModifiers(isAbstract: generateAbstractly, isNew: addNew, isUnsafe: addUnsafe);
+                var modifiers = new DeclarationModifiers(isStatic: member.IsStatic, isAbstract: generateAbstractly, isNew: addNew, isUnsafe: addUnsafe);
 
                 var useExplicitInterfaceSymbol = generateInvisibly || !Service.CanImplementImplicitly;
                 var accessibility = member.Name == memberName || generateAbstractly
diff --git a/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction_Method.cs b/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction_Method.cs
index fb8f63adbdd11..7ec7b25926695 100644
--- a/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction_Method.cs
+++ b/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction_Method.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Editing;
@@ -25,7 +23,7 @@ private ISymbol GenerateMethod(
                 bool useExplicitInterfaceSymbol,
                 string memberName)
             {
-                var syntaxFacts = Document.GetLanguageService<ISyntaxFactsService>();
+                var syntaxFacts = Document.GetRequiredLanguageService<ISyntaxFactsService>();
 
                 var updatedMethod = method.EnsureNonConflictingNames(State.ClassOrStructType, syntaxFacts);
 
diff --git a/src/Features/Core/Portable/InheritanceMargin/InheritanceRelationship.cs b/src/Features/Core/Portable/InheritanceMargin/InheritanceRelationship.cs
index d5133fc5e8dd0..7715f132eb745 100644
--- a/src/Features/Core/Portable/InheritanceMargin/InheritanceRelationship.cs
+++ b/src/Features/Core/Portable/InheritanceMargin/InheritanceRelationship.cs
@@ -18,34 +18,48 @@ internal enum InheritanceRelationship
         None = 0,
 
         /// <summary>
-        /// Indicate the target is implementing the member. It would be shown as I↑.
+        /// Implented interfaces for class or struct. Shown as I↑
         /// </summary>
-        Implementing = 1,
+        ImplementedInterface = 1,
 
         /// <summary>
-        /// Indicate the target is implemented by the member. It would be shown as I↓.
+        /// Base type for class or struct. Shown as O↑
         /// </summary>
-        Implemented = 2,
+        BaseType = 2,
 
         /// <summary>
-        /// Indicate the target is overriding the member. It would be shown as O↑.
+        /// Derived type for class or struct. Shown as O↓
         /// </summary>
-        Overriding = 4,
+        DerivedType = 4,
 
         /// <summary>
-        /// Indicate the target is overridden by the member. It would be shown as O↓.
+        /// Inherited interface for interface. Shown as I↑
         /// </summary>
-        Overridden = 8,
+        InheritedInterface = 8,
 
         /// <summary>
-        /// A compound value for indicating there are multiple targets both implementing and overriding the member.
+        /// Implementing class, struct and interface for interface. Shown as I↓
         /// </summary>
-        ImplementingOverriding = InheritanceRelationship.Implementing | InheritanceRelationship.Overriding,
+        ImplementingType = 16,
 
         /// <summary>
-        /// A compound value for indicating there are multiple targets both implementing the member and overriden by the member.
+        /// Implemented member for member in class or structure. Shown as I↑
         /// </summary>
-        ImplementingOverridden = InheritanceRelationship.Implementing | InheritanceRelationship.Overridden
+        ImplementedMember = 32,
 
+        /// <summary>
+        /// Overridden member for member in class or structure. Shown as O↑
+        /// </summary>
+        OverriddenMember = 64,
+
+        /// <summary>
+        /// Overrrding member for member in class or structure. Shown as O↓
+        /// </summary>
+        OverridingMember = 128,
+
+        /// <summary>
+        /// Implmenting member for member in interface. Shown as I↓
+        /// </summary>
+        ImplementingMember = 256
     }
 }
diff --git a/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterService.cs b/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterService.cs
index 15f6ea0cd5e6c..42d8243ae3363 100644
--- a/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterService.cs
+++ b/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterService.cs
@@ -69,6 +69,13 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex
                 return;
             }
 
+            // Need to special case for highlighting of method types because they are also "contained" within a method,
+            // but it does not make sense to introduce a parameter in that case.
+            if (syntaxFacts.IsInNamespaceOrTypeContext(expression))
+            {
+                return;
+            }
+
             var generator = SyntaxGenerator.GetGenerator(document);
             var containingMethod = expression.FirstAncestorOrSelf<SyntaxNode>(node => generator.GetParameterListNode(node) is not null);
 
@@ -106,10 +113,17 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex
             var singleLineExpression = syntaxFacts.ConvertToSingleLine(expression);
             var nodeString = singleLineExpression.ToString();
 
-            context.RegisterRefactoring(new CodeActionWithNestedActions(
-                string.Format(FeaturesResources.Introduce_parameter_for_0, nodeString), actions.Value.actions, isInlinable: false), textSpan);
-            context.RegisterRefactoring(new CodeActionWithNestedActions(
-                string.Format(FeaturesResources.Introduce_parameter_for_all_occurrences_of_0, nodeString), actions.Value.actionsAllOccurrences, isInlinable: false), textSpan);
+            if (actions.Value.actions.Length > 0)
+            {
+                context.RegisterRefactoring(new CodeActionWithNestedActions(
+                    string.Format(FeaturesResources.Introduce_parameter_for_0, nodeString), actions.Value.actions, isInlinable: false), textSpan);
+            }
+
+            if (actions.Value.actionsAllOccurrences.Length > 0)
+            {
+                context.RegisterRefactoring(new CodeActionWithNestedActions(
+                    string.Format(FeaturesResources.Introduce_parameter_for_all_occurrences_of_0, nodeString), actions.Value.actionsAllOccurrences, isInlinable: false), textSpan);
+            }
         }
 
         /// <summary>
diff --git a/src/Features/Core/Portable/InvertIf/AbstractInvertIfCodeRefactoringProvider.cs b/src/Features/Core/Portable/InvertIf/AbstractInvertIfCodeRefactoringProvider.cs
index 7011664594501..9c913c0905026 100644
--- a/src/Features/Core/Portable/InvertIf/AbstractInvertIfCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/InvertIf/AbstractInvertIfCodeRefactoringProvider.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -63,9 +61,9 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex
         private InvertIfStyle GetInvertIfStyle(
             TIfStatementSyntax ifNode,
             SemanticModel semanticModel,
-            out SyntaxNode subsequentSingleExitPointOpt)
+            out SyntaxNode? subsequentSingleExitPoint)
         {
-            subsequentSingleExitPointOpt = null;
+            subsequentSingleExitPoint = null;
 
             if (!IsElseless(ifNode))
             {
@@ -117,7 +115,7 @@ private InvertIfStyle GetInvertIfStyle(
             AnalyzeSubsequentControlFlow(
                 semanticModel, subsequentStatementRanges,
                 out var subsequentEndPointIsReachable,
-                out subsequentSingleExitPointOpt);
+                out subsequentSingleExitPoint);
 
             if (subsequentEndPointIsReachable)
             {
@@ -173,7 +171,7 @@ private InvertIfStyle GetInvertIfStyle(
             }
             else if (ifBodyEndPointIsReachable)
             {
-                if (subsequentSingleExitPointOpt != null &&
+                if (subsequentSingleExitPoint != null &&
                     SingleSubsequentStatement(subsequentStatementRanges))
                 {
                     // (5) if-body end-point is reachable but the next statement is a only jump-statement.
@@ -248,18 +246,18 @@ private async Task<Document> InvertIfAsync(
             TIfStatementSyntax ifNode,
             CancellationToken cancellationToken)
         {
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-            var invertIfStyle = GetInvertIfStyle(ifNode, semanticModel, out var subsequentSingleExitPointOpt);
-            var generator = document.GetLanguageService<SyntaxGenerator>();
+            var invertIfStyle = GetInvertIfStyle(ifNode, semanticModel, out var subsequentSingleExitPoint);
+            var generator = document.GetRequiredLanguageService<SyntaxGenerator>();
             return document.WithSyntaxRoot(
                 GetRootWithInvertIfStatement(
                     sourceText,
                     root,
                     ifNode,
                     invertIfStyle,
-                    subsequentSingleExitPointOpt,
+                    subsequentSingleExitPoint,
                     negatedExpression: generator.Negate(
                         generator.SyntaxGeneratorInternal,
                         GetCondition(ifNode),
@@ -271,10 +269,10 @@ private static void AnalyzeSubsequentControlFlow(
             SemanticModel semanticModel,
             ImmutableArray<StatementRange> subsequentStatementRanges,
             out bool subsequentEndPointIsReachable,
-            out SyntaxNode subsequentSingleExitPointOpt)
+            out SyntaxNode? subsequentSingleExitPoint)
         {
             subsequentEndPointIsReachable = true;
-            subsequentSingleExitPointOpt = null;
+            subsequentSingleExitPoint = null;
 
             foreach (var statementRange in subsequentStatementRanges)
             {
@@ -282,7 +280,7 @@ private static void AnalyzeSubsequentControlFlow(
                     semanticModel,
                     statementRange,
                     out subsequentEndPointIsReachable,
-                    out subsequentSingleExitPointOpt);
+                    out subsequentSingleExitPoint);
 
                 if (!subsequentEndPointIsReachable)
                 {
@@ -295,14 +293,14 @@ private static void AnalyzeControlFlow(
             SemanticModel semanticModel,
             StatementRange statementRange,
             out bool endPointIsReachable,
-            out SyntaxNode singleExitPointOpt)
+            out SyntaxNode? singleExitPoint)
         {
             var flow = semanticModel.AnalyzeControlFlow(
                 statementRange.FirstStatement,
                 statementRange.LastStatement);
 
             endPointIsReachable = flow.EndPointIsReachable;
-            singleExitPointOpt = flow.ExitPoints.Length == 1 ? flow.ExitPoints[0] : null;
+            singleExitPoint = flow.ExitPoints.Length == 1 ? flow.ExitPoints[0] : null;
         }
 
         private static bool SubsequentStatementsAreInTheSameBlock(
@@ -381,7 +379,7 @@ private ImmutableArray<StatementRange> GetSubsequentStatementRanges(TIfStatement
         protected abstract string GetTitle();
 
         protected abstract SyntaxList<TStatementSyntax> GetStatements(SyntaxNode node);
-        protected abstract TStatementSyntax GetNextStatement(TStatementSyntax node);
+        protected abstract TStatementSyntax? GetNextStatement(TStatementSyntax node);
 
         protected abstract TStatementSyntax GetJumpStatement(int rawKind);
         protected abstract int GetJumpStatementRawKind(SyntaxNode node);
@@ -413,7 +411,7 @@ protected abstract TIfStatementSyntax UpdateIf(
             TIfStatementSyntax ifNode,
             SyntaxNode condition,
             TEmbeddedStatement trueStatement,
-            TEmbeddedStatement falseStatementOpt = default);
+            TEmbeddedStatement? falseStatement = default);
 
         protected abstract SyntaxNode WithStatements(
             SyntaxNode node,
@@ -424,7 +422,7 @@ private SyntaxNode GetRootWithInvertIfStatement(
             SyntaxNode root,
             TIfStatementSyntax ifNode,
             InvertIfStyle invertIfStyle,
-            SyntaxNode subsequentSingleExitPointOpt,
+            SyntaxNode? subsequentSingleExitPoint,
             SyntaxNode negatedExpression)
         {
             switch (invertIfStyle)
@@ -435,8 +433,8 @@ private SyntaxNode GetRootWithInvertIfStatement(
                             text,
                             ifNode: ifNode,
                             condition: negatedExpression,
-                            trueStatement: GetElseBody(ifNode),
-                            falseStatementOpt: GetIfBody(ifNode));
+                            trueStatement: GetElseBody(ifNode)!,
+                            falseStatement: GetIfBody(ifNode));
 
                         return root.ReplaceNode(ifNode, updatedIf);
                     }
@@ -448,7 +446,7 @@ private SyntaxNode GetRootWithInvertIfStatement(
                             ifNode: ifNode,
                             condition: negatedExpression,
                             trueStatement: GetEmptyEmbeddedStatement(),
-                            falseStatementOpt: GetIfBody(ifNode));
+                            falseStatement: GetIfBody(ifNode));
 
                         return root.ReplaceNode(ifNode, updatedIf);
                     }
@@ -466,7 +464,7 @@ private SyntaxNode GetRootWithInvertIfStatement(
 
                 case InvertIfStyle.IfWithoutElse_SwapIfBodyWithSubsequentStatements:
                     {
-                        var currentParent = ifNode.Parent;
+                        var currentParent = ifNode.GetRequiredParent();
                         var statements = GetStatements(currentParent);
                         var index = statements.IndexOf(ifNode);
 
@@ -490,7 +488,7 @@ private SyntaxNode GetRootWithInvertIfStatement(
 
                 case InvertIfStyle.IfWithoutElse_WithNearmostJumpStatement:
                     {
-                        var currentParent = ifNode.Parent;
+                        var currentParent = ifNode.GetRequiredParent();
                         var statements = GetStatements(currentParent);
                         var index = statements.IndexOf(ifNode);
 
@@ -515,14 +513,14 @@ private SyntaxNode GetRootWithInvertIfStatement(
 
                 case InvertIfStyle.IfWithoutElse_WithSubsequentExitPointStatement:
                     {
-                        Debug.Assert(subsequentSingleExitPointOpt is TStatementSyntax);
+                        Debug.Assert(subsequentSingleExitPoint is TStatementSyntax);
 
-                        var currentParent = ifNode.Parent;
+                        var currentParent = ifNode.GetRequiredParent();
                         var statements = GetStatements(currentParent);
                         var index = statements.IndexOf(ifNode);
 
                         var ifBody = GetIfBody(ifNode);
-                        var newIfBody = (TStatementSyntax)subsequentSingleExitPointOpt;
+                        var newIfBody = (TStatementSyntax)subsequentSingleExitPoint;
 
                         var updatedIf = UpdateIf(
                             text,
@@ -542,7 +540,7 @@ private SyntaxNode GetRootWithInvertIfStatement(
 
                 case InvertIfStyle.IfWithoutElse_MoveSubsequentStatementsToIfBody:
                     {
-                        var currentParent = ifNode.Parent;
+                        var currentParent = ifNode.GetRequiredParent();
                         var statements = GetStatements(currentParent);
                         var index = statements.IndexOf(ifNode);
 
@@ -565,7 +563,7 @@ private SyntaxNode GetRootWithInvertIfStatement(
 
                 case InvertIfStyle.IfWithoutElse_WithElseClause:
                     {
-                        var currentParent = ifNode.Parent;
+                        var currentParent = ifNode.GetRequiredParent();
                         var statements = GetStatements(currentParent);
                         var index = statements.IndexOf(ifNode);
 
@@ -579,7 +577,7 @@ private SyntaxNode GetRootWithInvertIfStatement(
                             ifNode: ifNode,
                             condition: negatedExpression,
                             trueStatement: AsEmbeddedStatement(statementsAfterIf, ifBody),
-                            falseStatementOpt: ifBody);
+                            falseStatement: ifBody);
 
                         var updatedParent = WithStatements(
                             currentParent,
diff --git a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AbstractSymbolDescriptionBuilder.cs b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AbstractSymbolDescriptionBuilder.cs
index c06f04b943495..fe8226cce6929 100644
--- a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AbstractSymbolDescriptionBuilder.cs
+++ b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AbstractSymbolDescriptionBuilder.cs
@@ -169,11 +169,11 @@ private void AddDocumentationContent(ISymbol symbol)
 
                 _documentationMap.Add(
                     SymbolDescriptionGroups.Documentation,
-                    symbol.GetDocumentationParts(_semanticModel, _position, formatter, CancellationToken).ToImmutableArray());
+                    symbol.GetDocumentationParts(_semanticModel, _position, formatter, CancellationToken));
 
                 _documentationMap.Add(
                     SymbolDescriptionGroups.RemarksDocumentation,
-                    symbol.GetRemarksDocumentationParts(_semanticModel, _position, formatter, CancellationToken).ToImmutableArray());
+                    symbol.GetRemarksDocumentationParts(_semanticModel, _position, formatter, CancellationToken));
 
                 AddReturnsDocumentationParts(symbol, formatter);
                 AddValueDocumentationParts(symbol, formatter);
diff --git a/src/Features/Core/Portable/MetadataAsSource/MetadataAsSourceFileService.cs b/src/Features/Core/Portable/MetadataAsSource/MetadataAsSourceFileService.cs
index d3187efe61d82..b05633d3cf97f 100644
--- a/src/Features/Core/Portable/MetadataAsSource/MetadataAsSourceFileService.cs
+++ b/src/Features/Core/Portable/MetadataAsSource/MetadataAsSourceFileService.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj b/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj
index 3f12ca28d393e..24dadfa1fdbb7 100644
--- a/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj
+++ b/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj
@@ -45,6 +45,8 @@
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Remote.Workspaces" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.Orchestrator" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.VisualStudio.TestWindow.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.VisualBasic.EditorFeatures" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.VisualBasic.Features" />
     <InternalsVisibleTo Include="Roslyn.Hosting.Diagnostics" />
@@ -99,6 +101,7 @@
     <InternalsVisibleTo Include="Microsoft.VisualStudio.CodeSense.ReferencesProvider" Key="$(VisualStudioKey)" WorkItem="https://github.com/dotnet/roslyn/issues/35086" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.CodeSense.TestsProvider" Key="$(VisualStudioKey)" WorkItem="https://github.com/dotnet/roslyn/issues/35086" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.Completion.Tests" Key="$(IntelliCodeCSharpKey)" WorkItem="https://github.com/dotnet/roslyn/issues/35081" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.VisualStudio.IntelliCode" Partner="IntelliCode" Key="$(IntelliCodeKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.VisualStudio.IntelliCode.CSharp" Partner="Pythia" Key="$(IntelliCodeCSharpKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.VisualStudio.IntelliCode.CSharp.Extraction" Partner="Pythia" Key="$(IntelliCodeCSharpKey)" />
     <RestrictedInternalsVisibleTo Include="dotnet-watch" Partner="Watch" Key="$(AspNetCoreKey)" />
diff --git a/src/Features/Core/Portable/NavigateTo/NavigateToUtilities.cs b/src/Features/Core/Portable/NavigateTo/NavigateToUtilities.cs
new file mode 100644
index 0000000000000..f44273dc3250b
--- /dev/null
+++ b/src/Features/Core/Portable/NavigateTo/NavigateToUtilities.cs
@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Navigation;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.NavigateTo
+{
+    internal static class NavigateToUtilities
+    {
+        public static ImmutableHashSet<string> GetKindsProvided(Solution solution)
+        {
+            var result = ImmutableHashSet.CreateBuilder<string>(StringComparer.Ordinal);
+            foreach (var project in solution.Projects)
+            {
+                var navigateToSearchService = project.GetLanguageService<INavigateToSearchService>();
+                if (navigateToSearchService != null)
+                    result.UnionWith(navigateToSearchService.KindsProvided);
+            }
+
+            return result.ToImmutable();
+        }
+
+        public static TextSpan GetBoundedSpan(INavigableItem item, SourceText sourceText)
+        {
+            var spanStart = item.SourceSpan.Start;
+            var spanEnd = item.SourceSpan.End;
+            if (item.IsStale)
+            {
+                // in the case of a stale item, the span may be out of bounds of the document. Cap
+                // us to the end of the document as that's where we're going to navigate the user
+                // to.
+                spanStart = spanStart > sourceText.Length ? sourceText.Length : spanStart;
+                spanEnd = spanEnd > sourceText.Length ? sourceText.Length : spanEnd;
+            }
+
+            return TextSpan.FromBounds(spanStart, spanEnd);
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/SolutionCrawler/GlobalOperationAwareIdleProcessor.cs b/src/Features/Core/Portable/SolutionCrawler/GlobalOperationAwareIdleProcessor.cs
index 99a212faeb0a3..a87224e638ec3 100644
--- a/src/Features/Core/Portable/SolutionCrawler/GlobalOperationAwareIdleProcessor.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/GlobalOperationAwareIdleProcessor.cs
@@ -21,9 +21,9 @@ internal abstract class GlobalOperationAwareIdleProcessor : IdleProcessor
         public GlobalOperationAwareIdleProcessor(
             IAsynchronousOperationListener listener,
             IGlobalOperationNotificationService globalOperationNotificationService,
-            int backOffTimeSpanInMs,
+            TimeSpan backOffTimeSpan,
             CancellationToken shutdownToken)
-            : base(listener, backOffTimeSpanInMs, shutdownToken)
+            : base(listener, backOffTimeSpan, shutdownToken)
         {
             _globalOperation = null;
             _globalOperationTask = Task.CompletedTask;
diff --git a/src/Features/Core/Portable/SolutionCrawler/IdleProcessor.cs b/src/Features/Core/Portable/SolutionCrawler/IdleProcessor.cs
index 5eb3bc29f5447..84618890b7bef 100644
--- a/src/Features/Core/Portable/SolutionCrawler/IdleProcessor.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/IdleProcessor.cs
@@ -12,28 +12,28 @@ namespace Microsoft.CodeAnalysis.SolutionCrawler
 {
     internal abstract class IdleProcessor
     {
-        private const int MinimumDelayInMS = 50;
+        private static readonly TimeSpan s_minimumDelay = TimeSpan.FromMilliseconds(50);
 
         protected readonly IAsynchronousOperationListener Listener;
         protected readonly CancellationToken CancellationToken;
-        protected readonly int BackOffTimeSpanInMS;
+        protected readonly TimeSpan BackOffTimeSpan;
 
         // points to processor task
         private Task? _processorTask;
 
         // there is one thread that writes to it and one thread reads from it
-        private int _lastAccessTimeInMS;
+        private SharedStopwatch _timeSinceLastAccess;
 
         public IdleProcessor(
             IAsynchronousOperationListener listener,
-            int backOffTimeSpanInMS,
+            TimeSpan backOffTimeSpan,
             CancellationToken cancellationToken)
         {
             Listener = listener;
             CancellationToken = cancellationToken;
 
-            BackOffTimeSpanInMS = backOffTimeSpanInMS;
-            _lastAccessTimeInMS = Environment.TickCount;
+            BackOffTimeSpan = backOffTimeSpan;
+            _timeSinceLastAccess = SharedStopwatch.StartNew();
         }
 
         protected abstract Task WaitAsync(CancellationToken cancellationToken);
@@ -46,7 +46,7 @@ protected void Start()
         }
 
         protected void UpdateLastAccessTime()
-            => _lastAccessTimeInMS = Environment.TickCount;
+            => _timeSinceLastAccess = SharedStopwatch.StartNew();
 
         protected async Task WaitForIdleAsync(IExpeditableDelaySource expeditableDelaySource)
         {
@@ -57,22 +57,22 @@ protected async Task WaitForIdleAsync(IExpeditableDelaySource expeditableDelaySo
                     return;
                 }
 
-                var diffInMS = Environment.TickCount - _lastAccessTimeInMS;
-                if (diffInMS >= BackOffTimeSpanInMS)
+                var diff = _timeSinceLastAccess.Elapsed;
+                if (diff >= BackOffTimeSpan)
                 {
                     return;
                 }
 
                 // TODO: will safestart/unwarp capture cancellation exception?
-                var timeLeft = BackOffTimeSpanInMS - diffInMS;
-                if (!await expeditableDelaySource.Delay(TimeSpan.FromMilliseconds(Math.Max(MinimumDelayInMS, timeLeft)), CancellationToken).ConfigureAwait(false))
+                var timeLeft = BackOffTimeSpan - diff;
+                if (!await expeditableDelaySource.Delay(TimeSpan.FromMilliseconds(Math.Max(s_minimumDelay.TotalMilliseconds, timeLeft.TotalMilliseconds)), CancellationToken).ConfigureAwait(false))
                 {
-                    // The delay terminated early to accommodate a blocking operation. Make sure to delay long
-                    // enough that low priority (on idle) operations get a chance to be triggered.
+                    // The delay terminated early to accommodate a blocking operation. Make sure to yield so low
+                    // priority (on idle) operations get a chance to be triggered.
                     //
-                    // 📝 At the time this was discovered, it was not clear exactly why the delay was needed in order
-                    // to avoid live-lock scenarios.
-                    await Task.Delay(TimeSpan.FromMilliseconds(10), CancellationToken).ConfigureAwait(false);
+                    // 📝 At the time this was discovered, it was not clear exactly why the yield (previously delay)
+                    // was needed in order to avoid live-lock scenarios.
+                    await Task.Yield().ConfigureAwait(false);
                     return;
                 }
             }
diff --git a/src/Features/Core/Portable/SolutionCrawler/InternalSolutionCrawlerOptions.cs b/src/Features/Core/Portable/SolutionCrawler/InternalSolutionCrawlerOptions.cs
index b6eb290a7754d..58529ebc46875 100644
--- a/src/Features/Core/Portable/SolutionCrawler/InternalSolutionCrawlerOptions.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/InternalSolutionCrawlerOptions.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using Microsoft.CodeAnalysis.Options;
 
 namespace Microsoft.CodeAnalysis.SolutionCrawler
@@ -16,22 +17,11 @@ internal static class InternalSolutionCrawlerOptions
         public static readonly Option2<bool> DirectDependencyPropagationOnly = new(nameof(InternalSolutionCrawlerOptions), "Project propagation only on direct dependency", defaultValue: true,
             storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "Project propagation only on direct dependency"));
 
-        public static readonly Option2<int> ActiveFileWorkerBackOffTimeSpanInMS = new(nameof(InternalSolutionCrawlerOptions), "Active file worker backoff timespan in ms", defaultValue: 100,
-            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "Active file worker backoff timespan in ms"));
-
-        public static readonly Option2<int> AllFilesWorkerBackOffTimeSpanInMS = new(nameof(InternalSolutionCrawlerOptions), "All files worker backoff timespan in ms", defaultValue: 1500,
-            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "All files worker backoff timespan in ms"));
-
-        public static readonly Option2<int> EntireProjectWorkerBackOffTimeSpanInMS = new(nameof(InternalSolutionCrawlerOptions), "Entire project analysis worker backoff timespan in ms", defaultValue: 5000,
-            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "Entire project analysis worker backoff timespan in ms"));
-
-        public static readonly Option2<int> SemanticChangeBackOffTimeSpanInMS = new(nameof(InternalSolutionCrawlerOptions), "Semantic change backoff timespan in ms", defaultValue: 100,
-            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "Semantic change backoff timespan in ms"));
-
-        public static readonly Option2<int> ProjectPropagationBackOffTimeSpanInMS = new(nameof(InternalSolutionCrawlerOptions), "Project propagation backoff timespan in ms", defaultValue: 500,
-            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "Project propagation backoff timespan in ms"));
-
-        public static readonly Option2<int> PreviewBackOffTimeSpanInMS = new(nameof(InternalSolutionCrawlerOptions), "Preview backoff timespan in ms", defaultValue: 500,
-            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "Preview backoff timespan in ms"));
+        public static readonly TimeSpan ActiveFileWorkerBackOffTimeSpan = TimeSpan.FromMilliseconds(100);
+        public static readonly TimeSpan AllFilesWorkerBackOffTimeSpan = TimeSpan.FromMilliseconds(1500);
+        public static readonly TimeSpan EntireProjectWorkerBackOffTimeSpan = TimeSpan.FromMilliseconds(5000);
+        public static readonly TimeSpan SemanticChangeBackOffTimeSpan = TimeSpan.FromMilliseconds(100);
+        public static readonly TimeSpan ProjectPropagationBackOffTimeSpan = TimeSpan.FromMilliseconds(500);
+        public static readonly TimeSpan PreviewBackOffTimeSpan = TimeSpan.FromMilliseconds(500);
     }
 }
diff --git a/src/Features/Core/Portable/SolutionCrawler/InternalSolutionCrawlerOptionsProvider.cs b/src/Features/Core/Portable/SolutionCrawler/InternalSolutionCrawlerOptionsProvider.cs
index 37ae86b2c73bc..2a5e8c14adad1 100644
--- a/src/Features/Core/Portable/SolutionCrawler/InternalSolutionCrawlerOptionsProvider.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/InternalSolutionCrawlerOptionsProvider.cs
@@ -22,11 +22,6 @@ public InternalSolutionCrawlerOptionsProvider()
 
         public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
             InternalSolutionCrawlerOptions.SolutionCrawler,
-            InternalSolutionCrawlerOptions.ActiveFileWorkerBackOffTimeSpanInMS,
-            InternalSolutionCrawlerOptions.AllFilesWorkerBackOffTimeSpanInMS,
-            InternalSolutionCrawlerOptions.EntireProjectWorkerBackOffTimeSpanInMS,
-            InternalSolutionCrawlerOptions.SemanticChangeBackOffTimeSpanInMS,
-            InternalSolutionCrawlerOptions.ProjectPropagationBackOffTimeSpanInMS,
-            InternalSolutionCrawlerOptions.PreviewBackOffTimeSpanInMS);
+            InternalSolutionCrawlerOptions.DirectDependencyPropagationOnly);
     }
 }
diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.AbstractPriorityProcessor.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.AbstractPriorityProcessor.cs
index 10f16c389c9cd..d84446da3ba92 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.AbstractPriorityProcessor.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.AbstractPriorityProcessor.cs
@@ -30,9 +30,9 @@ public AbstractPriorityProcessor(
                         IncrementalAnalyzerProcessor processor,
                         Lazy<ImmutableArray<IIncrementalAnalyzer>> lazyAnalyzers,
                         IGlobalOperationNotificationService globalOperationNotificationService,
-                        int backOffTimeSpanInMs,
+                        TimeSpan backOffTimeSpan,
                         CancellationToken shutdownToken)
-                        : base(listener, globalOperationNotificationService, backOffTimeSpanInMs, shutdownToken)
+                        : base(listener, globalOperationNotificationService, backOffTimeSpan, shutdownToken)
                     {
                         _gate = new object();
                         _lazyAnalyzers = lazyAnalyzers;
diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.HighPriorityProcessor.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.HighPriorityProcessor.cs
index b857367086186..33fe20c27b821 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.HighPriorityProcessor.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.HighPriorityProcessor.cs
@@ -35,9 +35,9 @@ public HighPriorityProcessor(
                         IAsynchronousOperationListener listener,
                         IncrementalAnalyzerProcessor processor,
                         Lazy<ImmutableArray<IIncrementalAnalyzer>> lazyAnalyzers,
-                        int backOffTimeSpanInMs,
+                        TimeSpan backOffTimeSpan,
                         CancellationToken shutdownToken)
-                        : base(listener, backOffTimeSpanInMs, shutdownToken)
+                        : base(listener, backOffTimeSpan, shutdownToken)
                     {
                         _processor = processor;
                         _lazyAnalyzers = lazyAnalyzers;
diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.IncrementalAnalyzerProcessor.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.IncrementalAnalyzerProcessor.cs
index 0b5f7d08d5f4a..bb5892d87acfb 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.IncrementalAnalyzerProcessor.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.IncrementalAnalyzerProcessor.cs
@@ -50,9 +50,9 @@ public IncrementalAnalyzerProcessor(
                     IEnumerable<Lazy<IIncrementalAnalyzerProvider, IncrementalAnalyzerProviderMetadata>> analyzerProviders,
                     bool initializeLazily,
                     Registration registration,
-                    int highBackOffTimeSpanInMs,
-                    int normalBackOffTimeSpanInMs,
-                    int lowBackOffTimeSpanInMs,
+                    TimeSpan highBackOffTimeSpan,
+                    TimeSpan normalBackOffTimeSpan,
+                    TimeSpan lowBackOffTimeSpan,
                     CancellationToken shutdownToken)
                 {
                     _logAggregator = new LogAggregator();
@@ -81,9 +81,9 @@ public IncrementalAnalyzerProcessor(
 
                     var globalNotificationService = _registration.Workspace.Services.GetRequiredService<IGlobalOperationNotificationService>();
 
-                    _highPriorityProcessor = new HighPriorityProcessor(listener, this, lazyActiveFileAnalyzers, highBackOffTimeSpanInMs, shutdownToken);
-                    _normalPriorityProcessor = new NormalPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, normalBackOffTimeSpanInMs, shutdownToken);
-                    _lowPriorityProcessor = new LowPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, lowBackOffTimeSpanInMs, shutdownToken);
+                    _highPriorityProcessor = new HighPriorityProcessor(listener, this, lazyActiveFileAnalyzers, highBackOffTimeSpan, shutdownToken);
+                    _normalPriorityProcessor = new NormalPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, normalBackOffTimeSpan, shutdownToken);
+                    _lowPriorityProcessor = new LowPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, lowBackOffTimeSpan, shutdownToken);
                 }
 
                 private static IDiagnosticAnalyzerService? GetDiagnosticAnalyzerService(IEnumerable<Lazy<IIncrementalAnalyzerProvider, IncrementalAnalyzerProviderMetadata>> analyzerProviders)
diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.LowPriorityProcessor.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.LowPriorityProcessor.cs
index 19b00ffb7a35b..de3db50989511 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.LowPriorityProcessor.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.LowPriorityProcessor.cs
@@ -30,9 +30,9 @@ public LowPriorityProcessor(
                         IncrementalAnalyzerProcessor processor,
                         Lazy<ImmutableArray<IIncrementalAnalyzer>> lazyAnalyzers,
                         IGlobalOperationNotificationService globalOperationNotificationService,
-                        int backOffTimeSpanInMs,
+                        TimeSpan backOffTimeSpan,
                         CancellationToken shutdownToken)
-                        : base(listener, processor, lazyAnalyzers, globalOperationNotificationService, backOffTimeSpanInMs, shutdownToken)
+                        : base(listener, processor, lazyAnalyzers, globalOperationNotificationService, backOffTimeSpan, shutdownToken)
                     {
                         _workItemQueue = new AsyncProjectWorkItemQueue(processor._registration.ProgressReporter, processor._registration.Workspace);
 
diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.NormalPriorityProcessor.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.NormalPriorityProcessor.cs
index 213ac6b540b6f..681e3ae8c5d49 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.NormalPriorityProcessor.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.NormalPriorityProcessor.cs
@@ -50,9 +50,9 @@ public NormalPriorityProcessor(
                         IncrementalAnalyzerProcessor processor,
                         Lazy<ImmutableArray<IIncrementalAnalyzer>> lazyAnalyzers,
                         IGlobalOperationNotificationService globalOperationNotificationService,
-                        int backOffTimeSpanInMs,
+                        TimeSpan backOffTimeSpan,
                         CancellationToken shutdownToken)
-                        : base(listener, processor, lazyAnalyzers, globalOperationNotificationService, backOffTimeSpanInMs, shutdownToken)
+                        : base(listener, processor, lazyAnalyzers, globalOperationNotificationService, backOffTimeSpan, shutdownToken)
                     {
                         _running = Task.CompletedTask;
                         _workItemQueue = new AsyncDocumentWorkItemQueue(processor._registration.ProgressReporter, processor._registration.Workspace);
diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.SemanticChangeProcessor.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.SemanticChangeProcessor.cs
index b5cf17f1660fd..25bdd62a21fe3 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.SemanticChangeProcessor.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.SemanticChangeProcessor.cs
@@ -41,16 +41,16 @@ public SemanticChangeProcessor(
                     IAsynchronousOperationListener listener,
                     Registration registration,
                     IncrementalAnalyzerProcessor documentWorkerProcessor,
-                    int backOffTimeSpanInMS,
-                    int projectBackOffTimeSpanInMS,
+                    TimeSpan backOffTimeSpan,
+                    TimeSpan projectBackOffTimeSpan,
                     CancellationToken cancellationToken)
-                    : base(listener, backOffTimeSpanInMS, cancellationToken)
+                    : base(listener, backOffTimeSpan, cancellationToken)
                 {
                     _gate = new SemaphoreSlim(initialCount: 0);
 
                     _registration = registration;
 
-                    _processor = new ProjectProcessor(listener, registration, documentWorkerProcessor, projectBackOffTimeSpanInMS, cancellationToken);
+                    _processor = new ProjectProcessor(listener, registration, documentWorkerProcessor, projectBackOffTimeSpan, cancellationToken);
 
                     _workGate = new NonReentrantLock();
                     _pendingWork = new Dictionary<DocumentId, Data>();
@@ -352,9 +352,9 @@ public ProjectProcessor(
                         IAsynchronousOperationListener listener,
                         Registration registration,
                         IncrementalAnalyzerProcessor processor,
-                        int backOffTimeSpanInMS,
+                        TimeSpan backOffTimeSpan,
                         CancellationToken cancellationToken)
-                        : base(listener, backOffTimeSpanInMS, cancellationToken)
+                        : base(listener, backOffTimeSpan, cancellationToken)
                     {
                         _registration = registration;
                         _processor = processor;
diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 7cf786abe40fe..430d5e1f23180 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -57,18 +57,18 @@ public WorkCoordinator(
 
                 _eventProcessingQueue = new TaskQueue(listener, TaskScheduler.Default);
 
-                var activeFileBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.ActiveFileWorkerBackOffTimeSpanInMS);
-                var allFilesWorkerBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.AllFilesWorkerBackOffTimeSpanInMS);
-                var entireProjectWorkerBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.EntireProjectWorkerBackOffTimeSpanInMS);
+                var activeFileBackOffTimeSpan = InternalSolutionCrawlerOptions.ActiveFileWorkerBackOffTimeSpan;
+                var allFilesWorkerBackOffTimeSpan = InternalSolutionCrawlerOptions.AllFilesWorkerBackOffTimeSpan;
+                var entireProjectWorkerBackOffTimeSpan = InternalSolutionCrawlerOptions.EntireProjectWorkerBackOffTimeSpan;
 
                 _documentAndProjectWorkerProcessor = new IncrementalAnalyzerProcessor(
                     listener, analyzerProviders, initializeLazily, _registration,
-                    activeFileBackOffTimeSpanInMS, allFilesWorkerBackOffTimeSpanInMS, entireProjectWorkerBackOffTimeSpanInMS, _shutdownToken);
+                    activeFileBackOffTimeSpan, allFilesWorkerBackOffTimeSpan, entireProjectWorkerBackOffTimeSpan, _shutdownToken);
 
-                var semanticBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.SemanticChangeBackOffTimeSpanInMS);
-                var projectBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.ProjectPropagationBackOffTimeSpanInMS);
+                var semanticBackOffTimeSpan = InternalSolutionCrawlerOptions.SemanticChangeBackOffTimeSpan;
+                var projectBackOffTimeSpan = InternalSolutionCrawlerOptions.ProjectPropagationBackOffTimeSpan;
 
-                _semanticChangeProcessor = new SemanticChangeProcessor(listener, _registration, _documentAndProjectWorkerProcessor, semanticBackOffTimeSpanInMS, projectBackOffTimeSpanInMS, _shutdownToken);
+                _semanticChangeProcessor = new SemanticChangeProcessor(listener, _registration, _documentAndProjectWorkerProcessor, semanticBackOffTimeSpan, projectBackOffTimeSpan, _shutdownToken);
 
                 // if option is on
                 if (_optionService.GetOption(InternalSolutionCrawlerOptions.SolutionCrawler))
diff --git a/src/Features/Core/Portable/UnusedReferences/UnusedReferencesRemover.cs b/src/Features/Core/Portable/UnusedReferences/UnusedReferencesRemover.cs
index e5259c283166b..12d1569b8909d 100644
--- a/src/Features/Core/Portable/UnusedReferences/UnusedReferencesRemover.cs
+++ b/src/Features/Core/Portable/UnusedReferences/UnusedReferencesRemover.cs
@@ -4,6 +4,7 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -34,6 +35,7 @@ public static async Task<ImmutableArray<ReferenceInfo>> GetUnusedReferencesAsync
                 .Where(project => projectFilePath.Equals(project.FilePath, System.StringComparison.OrdinalIgnoreCase));
 
             HashSet<string> usedAssemblyFilePaths = new();
+            HashSet<string> usedProjectFileNames = new();
 
             foreach (var project in projects)
             {
@@ -50,13 +52,21 @@ public static async Task<ImmutableArray<ReferenceInfo>> GetUnusedReferencesAsync
                     .OfType<PortableExecutableReference>()
                     .Select(reference => reference.FilePath)
                     .WhereNotNull());
+
+                // Compilation references do not contain the full path to the output assembly so we track them
+                // by file name.
+                usedProjectFileNames.AddRange(usedAssemblyReferences
+                    .OfType<CompilationReference>()
+                    .Select(reference => reference.Compilation.SourceModule.MetadataName)
+                    .WhereNotNull());
             }
 
-            return GetUnusedReferences(usedAssemblyFilePaths, references);
+            return GetUnusedReferences(usedAssemblyFilePaths, usedProjectFileNames, references);
         }
 
         internal static ImmutableArray<ReferenceInfo> GetUnusedReferences(
             HashSet<string> usedAssemblyFilePaths,
+            HashSet<string> usedProjectFileNames,
             ImmutableArray<ReferenceInfo> references)
         {
             var unusedReferencesBuilder = ImmutableArray.CreateBuilder<ReferenceInfo>();
@@ -85,7 +95,8 @@ internal static ImmutableArray<ReferenceInfo> GetUnusedReferences(
 
                 var unusedReferences = RemoveDirectlyUsedReferences(
                     referencesForReferenceType,
-                    usedAssemblyFilePaths);
+                    usedAssemblyFilePaths,
+                    usedProjectFileNames);
 
                 // Update with the references that are remaining.
                 if (unusedReferences.IsEmpty)
@@ -119,7 +130,8 @@ internal static ImmutableArray<ReferenceInfo> GetUnusedReferences(
 
         private static ImmutableArray<ReferenceInfo> RemoveDirectlyUsedReferences(
             ImmutableArray<ReferenceInfo> references,
-            HashSet<string> usedAssemblyFilePaths)
+            HashSet<string> usedAssemblyFilePaths,
+            HashSet<string> usedProjectFileNames)
         {
             // In this method we will check if a reference directly brings in a used compilation assembly.
             //
@@ -131,19 +143,42 @@ private static ImmutableArray<ReferenceInfo> RemoveDirectlyUsedReferences(
 
             foreach (var reference in references)
             {
-                // We will look at the compilation assemblies brought in directly by the
-                // references to see if they are used.
-                if (!reference.CompilationAssemblies.Any(usedAssemblyFilePaths.Contains))
+                if (reference.ReferenceType == ReferenceType.Project)
                 {
-                    // None of the assemblies brought into this compilation are in the
-                    // used assemblies list, so we will consider the reference unused.
-                    unusedReferencesBuilder.Add(reference);
-                    continue;
+                    // Since we only know project references by their CompilationReference which
+                    // does not include the full output path. We look only at the file name of the
+                    // compilation assembly and compare it with our list of used project assembly names.
+                    var projectAssemblyFileNames = reference.CompilationAssemblies
+                        .SelectAsArray(assemblyPath => Path.GetFileName(assemblyPath));
+
+                    // We will look at the project assemblies brought in directly by the
+                    // references to see if they are used.
+                    if (!projectAssemblyFileNames.Any(usedProjectFileNames.Contains))
+                    {
+                        // None of the project assemblies brought into this compilation are in the
+                        // used assemblies list, so we will consider the reference unused.
+                        unusedReferencesBuilder.Add(reference);
+                        continue;
+                    }
+
+                    // Remove the project file name now that we've identified it.
+                    usedProjectFileNames.ExceptWith(projectAssemblyFileNames);
+                }
+                else
+                {
+                    // We will look at the compilation assemblies brought in directly by the
+                    // references to see if they are used.
+                    if (!reference.CompilationAssemblies.Any(usedAssemblyFilePaths.Contains))
+                    {
+                        // None of the assemblies brought into this compilation are in the
+                        // used assemblies list, so we will consider the reference unused.
+                        unusedReferencesBuilder.Add(reference);
+                        continue;
+                    }
                 }
 
                 // Remove all assemblies that are brought into this compilation by this reference.
                 usedAssemblyFilePaths.ExceptWith(GetAllCompilationAssemblies(reference));
-
             }
 
             return unusedReferencesBuilder.ToImmutable();
diff --git a/src/Features/Core/Portable/ValueTracking/IValueTrackingService.cs b/src/Features/Core/Portable/ValueTracking/IValueTrackingService.cs
new file mode 100644
index 0000000000000..7f21b4c70ef30
--- /dev/null
+++ b/src/Features/Core/Portable/ValueTracking/IValueTrackingService.cs
@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.ValueTracking
+{
+    internal interface IValueTrackingService : IWorkspaceService
+    {
+        Task<ImmutableArray<ValueTrackedItem>> TrackValueSourceAsync(TextSpan selection, Document document, CancellationToken cancellationToken);
+        Task<ImmutableArray<ValueTrackedItem>> TrackValueSourceAsync(Solution solution, ValueTrackedItem previousTrackedItem, CancellationToken cancellationToken);
+    }
+
+    internal interface IRemoteValueTrackingService
+    {
+        ValueTask<ImmutableArray<SerializableValueTrackedItem>> TrackValueSourceAsync(PinnedSolutionInfo solutionInfo, TextSpan selection, DocumentId document, CancellationToken cancellationToken);
+        ValueTask<ImmutableArray<SerializableValueTrackedItem>> TrackValueSourceAsync(PinnedSolutionInfo solutionInfo, SerializableValueTrackedItem previousTrackedItem, CancellationToken cancellationToken);
+    }
+}
diff --git a/src/Features/Core/Portable/ValueTracking/SerializableValueTrackedItem.cs b/src/Features/Core/Portable/ValueTracking/SerializableValueTrackedItem.cs
new file mode 100644
index 0000000000000..e5840f18ea09e
--- /dev/null
+++ b/src/Features/Core/Portable/ValueTracking/SerializableValueTrackedItem.cs
@@ -0,0 +1,68 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.Serialization;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.ValueTracking
+{
+    [DataContract]
+    internal sealed class SerializableValueTrackedItem
+    {
+        [DataMember(Order = 0)]
+        public SymbolKey SymbolKey { get; }
+
+        [DataMember(Order = 1)]
+        public TextSpan TextSpan { get; }
+
+        [DataMember(Order = 2)]
+        public DocumentId DocumentId { get; }
+
+        [DataMember(Order = 3)]
+        public SerializableValueTrackedItem? Parent { get; }
+
+        public SerializableValueTrackedItem(
+            SymbolKey symbolKey,
+            TextSpan textSpan,
+            DocumentId documentId,
+            SerializableValueTrackedItem? parent = null)
+        {
+            SymbolKey = symbolKey;
+            Parent = parent;
+            TextSpan = textSpan;
+            DocumentId = documentId;
+        }
+
+        public static SerializableValueTrackedItem Dehydrate(Solution solution, ValueTrackedItem valueTrackedItem, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var parent = valueTrackedItem.Parent is null
+                ? null
+                : Dehydrate(solution, valueTrackedItem.Parent, cancellationToken);
+
+            return new SerializableValueTrackedItem(valueTrackedItem.SymbolKey, valueTrackedItem.Span, valueTrackedItem.DocumentId, parent);
+        }
+
+        public async Task<ValueTrackedItem?> RehydrateAsync(Solution solution, CancellationToken cancellationToken)
+        {
+            var document = solution.GetRequiredDocument(DocumentId);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var symbolResolution = SymbolKey.Resolve(semanticModel.Compilation, cancellationToken: cancellationToken);
+
+            if (symbolResolution.Symbol is null)
+            {
+                return null;
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+            var parent = Parent is null ? null : await Parent.RehydrateAsync(solution, cancellationToken).ConfigureAwait(false);
+
+            return await ValueTrackedItem.TryCreateAsync(document, TextSpan, symbolResolution.Symbol, parent, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/ValueTracking/ValueTrackedItem.cs b/src/Features/Core/Portable/ValueTracking/ValueTrackedItem.cs
new file mode 100644
index 0000000000000..5d4654fd52358
--- /dev/null
+++ b/src/Features/Core/Portable/ValueTracking/ValueTrackedItem.cs
@@ -0,0 +1,95 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.ValueTracking
+{
+    internal class ValueTrackedItem
+    {
+        public SymbolKey SymbolKey { get; }
+        public ValueTrackedItem? Parent { get; }
+
+        public DocumentId DocumentId { get; }
+        public TextSpan Span { get; }
+        public ImmutableArray<ClassifiedSpan> ClassifiedSpans { get; }
+        public SourceText SourceText { get; }
+        public Glyph Glyph { get; }
+
+        private ValueTrackedItem(
+            SymbolKey symbolKey,
+            SourceText sourceText,
+            ImmutableArray<ClassifiedSpan> classifiedSpans,
+            TextSpan textSpan,
+            DocumentId documentId,
+            Glyph glyph,
+            ValueTrackedItem? parent = null)
+        {
+            SymbolKey = symbolKey;
+            Parent = parent;
+            Glyph = glyph;
+            Span = textSpan;
+            ClassifiedSpans = classifiedSpans;
+            SourceText = sourceText;
+            DocumentId = documentId;
+        }
+
+        public override string ToString()
+        {
+            var subText = SourceText.GetSubText(Span);
+            return subText.ToString();
+        }
+
+        public static Task<ValueTrackedItem?> TryCreateAsync(Solution solution, Location location, ISymbol symbol, ValueTrackedItem? parent = null, CancellationToken cancellationToken = default)
+        {
+            Contract.ThrowIfNull(location.SourceTree);
+
+            var document = solution.GetRequiredDocument(location.SourceTree);
+            return TryCreateAsync(document, location.SourceSpan, symbol, parent, cancellationToken);
+        }
+
+        public static async Task<ValueTrackedItem?> TryCreateAsync(Document document, TextSpan textSpan, ISymbol symbol, ValueTrackedItem? parent = null, CancellationToken cancellationToken = default)
+        {
+            var excerptService = document.Services.GetService<IDocumentExcerptService>();
+            SourceText? sourceText = null;
+            ImmutableArray<ClassifiedSpan> classifiedSpans = default;
+
+            if (excerptService != null)
+            {
+                var result = await excerptService.TryExcerptAsync(document, textSpan, ExcerptMode.SingleLine, cancellationToken).ConfigureAwait(false);
+                if (result.HasValue)
+                {
+                    var value = result.Value;
+                    sourceText = value.Content;
+                }
+            }
+
+            if (sourceText is null)
+            {
+                var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+                var classificationResult = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(documentSpan, cancellationToken).ConfigureAwait(false);
+                classifiedSpans = classificationResult.ClassifiedSpans;
+                var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+                sourceText = await syntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            return new ValueTrackedItem(
+                        SymbolKey.Create(symbol, cancellationToken),
+                        sourceText,
+                        classifiedSpans,
+                        textSpan,
+                        document.Id,
+                        symbol.GetGlyph(),
+                        parent: parent);
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/ValueTracking/ValueTracker.FindReferencesProgress.cs b/src/Features/Core/Portable/ValueTracking/ValueTracker.FindReferencesProgress.cs
new file mode 100644
index 0000000000000..017373779b62a
--- /dev/null
+++ b/src/Features/Core/Portable/ValueTracking/ValueTracker.FindReferencesProgress.cs
@@ -0,0 +1,147 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.FindSymbols;
+using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.Utilities;
+
+namespace Microsoft.CodeAnalysis.ValueTracking
+{
+    internal static partial class ValueTracker
+    {
+        private class FindReferencesProgress : IStreamingFindReferencesProgress, IStreamingProgressTracker
+        {
+            private readonly OperationCollector _operationCollector;
+            public FindReferencesProgress(OperationCollector valueTrackingProgressCollector)
+            {
+                _operationCollector = valueTrackingProgressCollector;
+            }
+
+            public IStreamingProgressTracker ProgressTracker => this;
+
+            public ValueTask AddItemsAsync(int count, CancellationToken _) => new();
+
+            public ValueTask ItemCompletedAsync(CancellationToken _) => new();
+
+            public ValueTask OnCompletedAsync(CancellationToken _) => new();
+
+            public ValueTask OnDefinitionFoundAsync(SymbolGroup symbolGroup, CancellationToken _) => new();
+
+            public ValueTask OnFindInDocumentCompletedAsync(Document document, CancellationToken _) => new();
+
+            public ValueTask OnFindInDocumentStartedAsync(Document document, CancellationToken _) => new();
+
+            public async ValueTask OnReferenceFoundAsync(SymbolGroup _, ISymbol symbol, ReferenceLocation location, CancellationToken cancellationToken)
+            {
+                if (!location.Location.IsInSource)
+                {
+                    return;
+                }
+
+                if (symbol is IMethodSymbol methodSymbol)
+                {
+                    if (methodSymbol.IsConstructor())
+                    {
+                        await TrackConstructorAsync(location, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        // If we're searching for references to a method, we don't want to store the symbol as that method again. Instead
+                        // we want to track the invocations and how to follow their source
+                        await TrackMethodInvocationArgumentsAsync(location, cancellationToken).ConfigureAwait(false);
+                    }
+                }
+                else if (location.IsWrittenTo)
+                {
+                    var syntaxFacts = location.Document.GetRequiredLanguageService<ISyntaxFactsService>();
+                    var node = location.Location.FindNode(CancellationToken.None);
+
+                    // Assignments to a member using a "this." or "Me." result in the node being an
+                    // identifier and the parent of the node being the member access expression. The member
+                    // access expression gives the right value for "IsLeftSideOfAnyAssignment" but also
+                    // gives the correct operation, where as the IdentifierSyntax does not.
+                    if (node.Parent is not null && syntaxFacts.IsAnyMemberAccessExpression(node.Parent))
+                    {
+                        node = node.Parent;
+                    }
+
+                    if (syntaxFacts.IsLeftSideOfAnyAssignment(node))
+                    {
+                        await AddItemsFromAssignmentAsync(location.Document, node, _operationCollector, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        var semanticModel = await location.Document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                        var operation = semanticModel.GetOperation(node, cancellationToken);
+                        if (operation is null)
+                        {
+                            return;
+                        }
+
+                        await _operationCollector.VisitAsync(operation, cancellationToken).ConfigureAwait(false);
+                    }
+                }
+            }
+
+            public ValueTask OnStartedAsync(CancellationToken _) => new();
+
+            private async Task TrackConstructorAsync(ReferenceLocation referenceLocation, CancellationToken cancellationToken)
+            {
+                var document = referenceLocation.Document;
+                var span = referenceLocation.Location.SourceSpan;
+
+                var syntaxRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+                var originalNode = syntaxRoot.FindNode(span);
+
+                if (originalNode is null || originalNode.Parent is null)
+                {
+                    return;
+                }
+
+                var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                var operation = semanticModel.GetOperation(originalNode.Parent, cancellationToken);
+                if (operation is not IObjectCreationOperation)
+                {
+                    return;
+                }
+
+                await _operationCollector.VisitAsync(operation, cancellationToken).ConfigureAwait(false);
+            }
+
+            private async Task TrackMethodInvocationArgumentsAsync(ReferenceLocation referenceLocation, CancellationToken cancellationToken)
+            {
+                var document = referenceLocation.Document;
+                var span = referenceLocation.Location.SourceSpan;
+
+                var syntaxRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+                var originalNode = syntaxRoot.FindNode(span);
+
+                if (originalNode is null)
+                {
+                    return;
+                }
+
+                var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
+                var invocationSyntax = originalNode.FirstAncestorOrSelf<SyntaxNode>(syntaxFacts.IsInvocationExpression);
+                if (invocationSyntax is null)
+                {
+                    return;
+                }
+
+                var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                var operation = semanticModel.GetOperation(invocationSyntax, cancellationToken);
+                if (operation is not IInvocationOperation)
+                {
+                    return;
+                }
+
+                await _operationCollector.VisitAsync(operation, cancellationToken).ConfigureAwait(false);
+            }
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/ValueTracking/ValueTracker.OperationCollector.cs b/src/Features/Core/Portable/ValueTracking/ValueTracker.OperationCollector.cs
new file mode 100644
index 0000000000000..87c09da0ac71d
--- /dev/null
+++ b/src/Features/Core/Portable/ValueTracking/ValueTracker.OperationCollector.cs
@@ -0,0 +1,302 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.ValueTracking
+{
+    internal static partial class ValueTracker
+    {
+        private class OperationCollector
+        {
+            public ValueTrackingProgressCollector ProgressCollector { get; }
+            public Solution Solution { get; }
+
+            public OperationCollector(ValueTrackingProgressCollector progressCollector, Solution solution)
+            {
+                ProgressCollector = progressCollector;
+                Solution = solution;
+            }
+
+            public Task VisitAsync(IOperation operation, CancellationToken cancellationToken)
+                => operation switch
+                {
+                    IObjectCreationOperation objectCreationOperation => VisitObjectCreationAsync(objectCreationOperation, cancellationToken),
+                    IInvocationOperation invocationOperation => VisitInvocationAsync(invocationOperation, cancellationToken),
+                    ILiteralOperation literalOperation => VisitLiteralAsync(literalOperation, cancellationToken),
+                    IReturnOperation returnOperation => VisitReturnAsync(returnOperation, cancellationToken),
+                    IArgumentOperation argumentOperation => ShouldTrackArgument(argumentOperation) ? VisitAsync(argumentOperation.Value, cancellationToken) : Task.CompletedTask,
+                    ILocalReferenceOperation or
+                        IParameterReferenceOperation or
+                        IFieldReferenceOperation or
+                        IPropertyReferenceOperation => VisitReferenceAsync(operation, cancellationToken),
+
+                    IAssignmentOperation assignmentOperation => VisitAssignmentOperationAsync(assignmentOperation, cancellationToken),
+                    IMethodBodyOperation methodBodyOperation => VisitReturnDescendentsAsync(methodBodyOperation, allowImplicit: true, cancellationToken),
+                    IBlockOperation blockOperation => VisitReturnDescendentsAsync(blockOperation, allowImplicit: false, cancellationToken),
+
+                    // Default to reporting if there is symbol information available
+                    _ => VisitDefaultAsync(operation, cancellationToken)
+                };
+
+            private async Task VisitReturnDescendentsAsync(IOperation operation, bool allowImplicit, CancellationToken cancellationToken)
+            {
+                var returnOperations = operation.Descendants().Where(d => d is IReturnOperation && (allowImplicit || !d.IsImplicit));
+                foreach (var returnOperation in returnOperations)
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    await VisitAsync(returnOperation, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            private async Task VisitDefaultAsync(IOperation operation, CancellationToken cancellationToken)
+            {
+                // If an operation has children, desend in them by default. 
+                // For cases that should not be descendend into, they should be explicitly handled
+                // in VisitAsync. 
+                // Ex: Binary operation of [| x + y |]
+                // both x and y should be evaluated separately
+                var childrenVisited = await TryVisitChildrenAsync(operation, cancellationToken).ConfigureAwait(false);
+
+                // In cases where the child operations were visited, they would be added instead of the parent
+                // currently being evaluated. Do not add the parent as well since it would be redundent. 
+                // Ex: Binary operation of [| x + y |]
+                // both x and y should be evaluated separately, but the whole operation should not be reported
+                if (childrenVisited)
+                {
+                    return;
+                }
+
+                var semanticModel = operation.SemanticModel;
+                if (semanticModel is null)
+                {
+                    return;
+                }
+
+                var symbolInfo = semanticModel.GetSymbolInfo(operation.Syntax, cancellationToken);
+                if (symbolInfo.Symbol is null)
+                {
+                    return;
+                }
+
+                await AddOperationAsync(operation, symbolInfo.Symbol, cancellationToken).ConfigureAwait(false);
+            }
+
+            private async Task<bool> TryVisitChildrenAsync(IOperation operation, CancellationToken cancellationToken)
+            {
+                foreach (var child in operation.Children)
+                {
+                    await VisitAsync(child, cancellationToken).ConfigureAwait(false);
+                }
+
+                return operation.Children.Any();
+            }
+
+            private Task VisitAssignmentOperationAsync(IAssignmentOperation assignmentOperation, CancellationToken cancellationToken)
+                => VisitAsync(assignmentOperation.Value, cancellationToken);
+
+            private Task VisitObjectCreationAsync(IObjectCreationOperation objectCreationOperation, CancellationToken cancellationToken)
+                => TrackArgumentsAsync(objectCreationOperation.Arguments, cancellationToken);
+
+            private async Task VisitInvocationAsync(IInvocationOperation invocationOperation, CancellationToken cancellationToken)
+            {
+                await AddOperationAsync(invocationOperation, invocationOperation.TargetMethod, cancellationToken).ConfigureAwait(false);
+                await TrackArgumentsAsync(invocationOperation.Arguments, cancellationToken).ConfigureAwait(false);
+            }
+
+            private Task VisitReferenceAsync(IOperation operation, CancellationToken cancellationToken)
+            {
+                Debug.Assert(operation is
+                    ILocalReferenceOperation or
+                    IParameterReferenceOperation or
+                    IFieldReferenceOperation or
+                    IPropertyReferenceOperation);
+
+                if (IsContainedIn<IArgumentOperation>(operation, out var argumentOperation) && argumentOperation.Parameter is not null)
+                {
+                    if (argumentOperation.Parameter.IsRefOrOut())
+                    {
+                        // Always add ref or out parameters to track as assignments since the values count as 
+                        // assignments across method calls for the purposes of value tracking.
+                        return AddOperationAsync(operation, argumentOperation.Parameter, cancellationToken);
+                    }
+
+                    // If the parameter is not a ref or out param, track the reference assignments that count
+                    // as input to the argument being passed to the method.
+                    return AddReference(operation, cancellationToken);
+                }
+
+                if (IsContainedIn<IReturnOperation>(operation) || IsContainedIn<IAssignmentOperation>(operation))
+                {
+                    // If the reference is part of a return operation or assignment operation we want to track where the values come from
+                    // since they contribute to the "output" of the method/assignment and are relavent for value tracking.
+                    return AddReference(operation, cancellationToken);
+                }
+
+                return Task.CompletedTask;
+
+                Task AddReference(IOperation operation, CancellationToken cancellationToken)
+                    => operation switch
+                    {
+                        IParameterReferenceOperation parameterReference => AddOperationAsync(operation, parameterReference.Parameter, cancellationToken),
+                        IFieldReferenceOperation fieldReferenceOperation => AddOperationAsync(operation, fieldReferenceOperation.Member, cancellationToken),
+                        IPropertyReferenceOperation propertyReferenceOperation => AddOperationAsync(operation, propertyReferenceOperation.Member, cancellationToken),
+                        ILocalReferenceOperation localReferenceOperation => AddOperationAsync(operation, localReferenceOperation.Local, cancellationToken),
+                        _ => Task.CompletedTask
+                    };
+            }
+
+            private Task VisitLiteralAsync(ILiteralOperation literalOperation, CancellationToken cancellationToken)
+            {
+                if (literalOperation.Type is null)
+                {
+                    return Task.CompletedTask;
+                }
+
+                return AddOperationAsync(literalOperation, literalOperation.Type, cancellationToken);
+            }
+
+            private Task VisitReturnAsync(IReturnOperation returnOperation, CancellationToken cancellationToken)
+            {
+                if (returnOperation.ReturnedValue is null)
+                {
+                    return Task.CompletedTask;
+                }
+
+                return VisitAsync(returnOperation.ReturnedValue, cancellationToken);
+            }
+
+            private async Task AddOperationAsync(IOperation operation, ISymbol symbol, CancellationToken cancellationToken)
+            {
+                _ = await ProgressCollector.TryReportAsync(
+                        Solution,
+                        operation.Syntax.GetLocation(),
+                        symbol,
+                        cancellationToken: cancellationToken).ConfigureAwait(false);
+            }
+
+            private async Task TrackArgumentsAsync(ImmutableArray<IArgumentOperation> argumentOperations, CancellationToken cancellationToken)
+            {
+                var collectorsAndArgumentMap = argumentOperations
+                    .Where(ShouldTrackArgument)
+                    // Clone the collector here to allow each argument to report multiple items.
+                    // See Clone() docs for more details
+                    .Select(argument => (collector: Clone(), argument))
+                    .ToImmutableArray();
+
+                var tasks = collectorsAndArgumentMap
+                    .Select(pair => Task.Run(() => pair.collector.VisitAsync(pair.argument, cancellationToken)));
+
+                await Task.WhenAll(tasks).ConfigureAwait(false);
+
+                var items = collectorsAndArgumentMap
+                    .Select(pair => pair.collector.ProgressCollector)
+                    .SelectMany(collector => collector.GetItems())
+                    .Reverse(); // ProgressCollector uses a Stack, and we want to maintain the order by arguments, so reverse
+
+                foreach (var item in items)
+                {
+                    ProgressCollector.Report(item);
+                }
+            }
+
+            /// <summary>
+            /// Clone the current collector into a new one with
+            /// the same parent but a separate progress collector.
+            /// This allows collection of items given the same state
+            /// as this collector while also keeping them "grouped" separately.
+            /// </summary>
+            /// <remarks>
+            /// This is useful for cases such as tracking arguments, where each
+            /// argument may be an expression or something else. We want to track each
+            /// argument expression in the correct order, but a single argument may produce
+            /// multiple items. By cloning we can track the items for each argument and then
+            /// gather them all at the end to report in the correct order.
+            /// </remarks>
+            private OperationCollector Clone()
+            {
+                var collector = new ValueTrackingProgressCollector
+                {
+                    Parent = ProgressCollector.Parent
+                };
+                return new OperationCollector(collector, Solution);
+            }
+
+            private static bool ShouldTrackArgument(IArgumentOperation argumentOperation)
+            {
+                // Ref or Out arguments always contribute data as "assignments"
+                // across method calls
+                if (argumentOperation.Parameter?.IsRefOrOut() == true)
+                {
+                    return true;
+                }
+
+                // If the argument value is an expression, binary operation, or
+                // invocation then parts of the operation need to be evaluated
+                // to see if they contribute data for value tracking
+                if (argumentOperation.Value is IExpressionStatementOperation
+                        or IBinaryOperation
+                        or IInvocationOperation)
+                {
+                    return true;
+                }
+
+                // If the argument value is a parameter reference, then the method calls
+                // leading to that parameter value should be tracked as well.
+                // Ex:
+                // string Prepend(string s1) => "pre" + s1;
+                // string CallPrepend(string [|s2|]) => Prepend(s2);
+                // Tracking [|s2|] into calls as an argument means that we 
+                // need to know where [|s2|] comes from and how it contributes
+                // to the value s1
+                if (argumentOperation.Value is IParameterReferenceOperation)
+                {
+                    return true;
+                }
+
+                // A literal value as an argument is a dead end for data, but still contributes
+                // to a value and should be shown in value tracking. It should never expand
+                // further though. 
+                // Ex:
+                // string Prepend(string [|s|]) => "pre" + s;
+                // string DefaultPrepend() => Prepend("default");
+                // [|s|] is the parameter we need to track values for, which 
+                // is assigned to "default" in DefaultPrepend
+                if (argumentOperation.Value is ILiteralOperation)
+                {
+                    return true;
+                }
+
+                return false;
+            }
+
+            private static bool IsContainedIn<TContainingOperation>(IOperation? operation) where TContainingOperation : IOperation
+                => IsContainedIn<TContainingOperation>(operation, out var _);
+
+            private static bool IsContainedIn<TContainingOperation>(IOperation? operation, [NotNullWhen(returnValue: true)] out TContainingOperation? containingOperation) where TContainingOperation : IOperation
+            {
+                while (operation is not null)
+                {
+                    if (operation is TContainingOperation tmpOperation)
+                    {
+                        containingOperation = tmpOperation;
+                        return true;
+                    }
+
+                    operation = operation.Parent;
+                }
+
+                containingOperation = default;
+                return false;
+            }
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/ValueTracking/ValueTracker.cs b/src/Features/Core/Portable/ValueTracking/ValueTracker.cs
new file mode 100644
index 0000000000000..7b60d5dffc3af
--- /dev/null
+++ b/src/Features/Core/Portable/ValueTracking/ValueTracker.cs
@@ -0,0 +1,334 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.FindSymbols;
+using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.ValueTracking
+{
+    internal static partial class ValueTracker
+    {
+        public static async Task TrackValueSourceAsync(
+            TextSpan selection,
+            Document document,
+            ValueTrackingProgressCollector progressCollector,
+            CancellationToken cancellationToken)
+        {
+            var (symbol, node) = await GetSelectedSymbolAsync(selection, document, cancellationToken).ConfigureAwait(false);
+            var operationCollector = new OperationCollector(progressCollector, document.Project.Solution);
+
+            if (symbol
+                is IPropertySymbol
+                or IFieldSymbol
+                or ILocalSymbol
+                or IParameterSymbol)
+            {
+                RoslynDebug.AssertNotNull(node);
+
+                var solution = document.Project.Solution;
+                var declaringSyntaxReferences = symbol.DeclaringSyntaxReferences;
+                var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
+
+                // If the selection is within a declaration of the symbol, we want to include
+                // all declarations and assignments of the symbol
+                if (declaringSyntaxReferences.Any(r => r.Span.IntersectsWith(selection)))
+                {
+                    // Add all initializations of the symbol. Those are not caught in 
+                    // the reference finder but should still show up in the tree
+                    foreach (var syntaxRef in declaringSyntaxReferences)
+                    {
+                        var location = Location.Create(syntaxRef.SyntaxTree, syntaxRef.Span);
+                        await progressCollector.TryReportAsync(solution, location, symbol, cancellationToken).ConfigureAwait(false);
+                    }
+
+                    await TrackVariableReferencesAsync(symbol, operationCollector, cancellationToken).ConfigureAwait(false);
+                }
+                // The selection is not on a declaration, check that the node
+                // is on the left side of an assignment. If so, populate so we can
+                // track the RHS values that contribute to this value
+                else if (syntaxFacts.IsLeftSideOfAnyAssignment(node))
+                {
+                    await AddItemsFromAssignmentAsync(document, node, operationCollector, cancellationToken).ConfigureAwait(false);
+                }
+                // Not on the left part of an assignment? Then just add an item with the statement
+                // and the symbol. It should be the top item, and children will find the sources
+                // of the value. A good example is a return statement, such as "return $$x",
+                // where $$ is the cursor position. The top item should have the return statement for
+                // context, and the remaining items should expand into the assignments of x
+                else
+                {
+                    await progressCollector.TryReportAsync(document.Project.Solution, node.GetLocation(), symbol, cancellationToken).ConfigureAwait(false);
+                }
+            }
+        }
+
+        public static async Task TrackValueSourceAsync(
+            Solution solution,
+            ValueTrackedItem previousTrackedItem,
+            ValueTrackingProgressCollector progressCollector,
+            CancellationToken cancellationToken)
+        {
+            progressCollector.Parent = previousTrackedItem;
+            var operationCollector = new OperationCollector(progressCollector, solution);
+            var symbol = await GetSymbolAsync(previousTrackedItem, solution, cancellationToken).ConfigureAwait(false);
+
+            switch (symbol)
+            {
+                case ILocalSymbol:
+                case IPropertySymbol:
+                case IFieldSymbol:
+                    {
+                        // The "output" is a variable assignment, track places where it gets assigned and defined
+                        await TrackVariableDefinitionsAsync(symbol, operationCollector, cancellationToken).ConfigureAwait(false);
+                        await TrackVariableReferencesAsync(symbol, operationCollector, cancellationToken).ConfigureAwait(false);
+                    }
+
+                    break;
+
+                case IParameterSymbol parameterSymbol:
+                    {
+                        var previousSymbol = await GetSymbolAsync(previousTrackedItem.Parent, solution, cancellationToken).ConfigureAwait(false);
+
+                        // If the current parameter is a parameter symbol for the previous tracked method it should be treated differently.
+                        // For example: 
+                        // string PrependString(string pre, string s) => pre + s;
+                        //        ^--- previously tracked          ^---- current parameter being tracked
+                        //
+                        // In this case, s is being tracked because it contributed to the return of the method. We only
+                        // want to track assignments to s that could impact the return rather than tracking the same method
+                        // twice.
+                        var isParameterForPreviousTrackedMethod = previousSymbol?.Equals(parameterSymbol.ContainingSymbol, SymbolEqualityComparer.Default) == true;
+
+                        // For Ref or Out parameters, they contribute data across method calls through assignments
+                        // within the method. No need to track returns
+                        // Ex: TryGetValue("mykey", out var [|v|])
+                        // [|v|] is the interesting part, we don't care what the method returns
+                        var isRefOrOut = parameterSymbol.IsRefOrOut();
+
+                        // Always track the parameter assignments as variables, in case they are assigned anywhere in the method
+                        await TrackVariableReferencesAsync(parameterSymbol, operationCollector, cancellationToken).ConfigureAwait(false);
+
+                        var trackMethod = !(isParameterForPreviousTrackedMethod || isRefOrOut);
+                        if (trackMethod)
+                        {
+                            await TrackParameterSymbolAsync(parameterSymbol, operationCollector, cancellationToken).ConfigureAwait(false);
+                        }
+                    }
+
+                    break;
+
+                case IMethodSymbol methodSymbol:
+                    {
+                        // The "output" is from a method, meaning it has a return or out param that is used. Track those 
+                        await TrackMethodSymbolAsync(methodSymbol, operationCollector, cancellationToken).ConfigureAwait(false);
+                    }
+
+                    break;
+            }
+        }
+
+        private static async Task AddItemsFromAssignmentAsync(Document document, SyntaxNode lhsNode, OperationCollector collector, CancellationToken cancellationToken)
+        {
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var operation = semanticModel.GetOperation(lhsNode, cancellationToken);
+            if (operation is null)
+            {
+                return;
+            }
+
+            IAssignmentOperation? assignmentOperation = null;
+
+            while (assignmentOperation is null
+                && operation is not null)
+            {
+                assignmentOperation = operation as IAssignmentOperation;
+                operation = operation.Parent;
+            }
+
+            if (assignmentOperation is null)
+            {
+                return;
+            }
+
+            await collector.VisitAsync(assignmentOperation, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static async Task TrackVariableReferencesAsync(ISymbol symbol, OperationCollector collector, CancellationToken cancellationToken)
+        {
+            var findReferenceProgressCollector = new FindReferencesProgress(collector);
+            await SymbolFinder.FindReferencesAsync(
+                                    symbol,
+                                    collector.Solution,
+                                    findReferenceProgressCollector,
+                                    documents: null, FindReferencesSearchOptions.Default, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static async Task TrackParameterSymbolAsync(
+            IParameterSymbol parameterSymbol,
+            OperationCollector collector,
+            CancellationToken cancellationToken)
+        {
+            var containingMethod = (IMethodSymbol)parameterSymbol.ContainingSymbol;
+            var findReferenceProgressCollector = new FindReferencesProgress(collector);
+            await SymbolFinder.FindReferencesAsync(
+                containingMethod,
+                collector.Solution,
+                findReferenceProgressCollector,
+                documents: null, FindReferencesSearchOptions.Default, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static async Task TrackMethodSymbolAsync(IMethodSymbol methodSymbol, OperationCollector collector, CancellationToken cancellationToken)
+        {
+            var hasAnyOutData = HasAValueReturn(methodSymbol) || HasAnOutOrRefParam(methodSymbol);
+            if (!hasAnyOutData)
+            {
+                // With no out data, there's nothing to do here
+                return;
+            }
+
+            // TODO: Use DFA to find meaningful returns? https://github.com/dotnet/roslyn-analyzers/blob/9e5f533cbafcc5579e4d758bc9bde27b7611ca54/docs/Writing%20dataflow%20analysis%20based%20analyzers.md 
+            if (HasAValueReturn(methodSymbol))
+            {
+                foreach (var location in methodSymbol.GetDefinitionLocationsToShow())
+                {
+                    if (location.SourceTree is null)
+                    {
+                        continue;
+                    }
+
+                    var node = location.FindNode(cancellationToken);
+                    var sourceDoc = collector.Solution.GetRequiredDocument(location.SourceTree);
+                    var syntaxFacts = sourceDoc.GetRequiredLanguageService<ISyntaxFactsService>();
+                    var semanticModel = await sourceDoc.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+
+                    var operation = semanticModel.GetOperation(node, cancellationToken);
+
+                    // In VB the parent node contains the operation (IBlockOperation) instead of the one returned
+                    // by the symbol location.
+                    if (operation is null && node.Parent is not null)
+                    {
+                        operation = semanticModel.GetOperation(node.Parent, cancellationToken);
+                    }
+
+                    if (operation is null)
+                    {
+                        continue;
+                    }
+
+                    await collector.VisitAsync(operation, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            if (HasAnOutOrRefParam(methodSymbol))
+            {
+                foreach (var outOrRefParam in methodSymbol.Parameters.Where(p => p.IsRefOrOut()))
+                {
+                    if (!outOrRefParam.IsFromSource())
+                    {
+                        continue;
+                    }
+
+                    await TrackVariableReferencesAsync(outOrRefParam, collector, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            // TODO check for Task
+            static bool HasAValueReturn(IMethodSymbol methodSymbol)
+            {
+                return methodSymbol.ReturnType.SpecialType != SpecialType.System_Void;
+            }
+
+            static bool HasAnOutOrRefParam(IMethodSymbol methodSymbol)
+            {
+                return methodSymbol.Parameters.Any(p => p.IsRefOrOut());
+            }
+        }
+
+        private static async Task<(ISymbol?, SyntaxNode?)> GetSelectedSymbolAsync(TextSpan textSpan, Document document, CancellationToken cancellationToken)
+        {
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var selectedNode = root.FindNode(textSpan);
+
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var selectedSymbol =
+                semanticModel.GetSymbolInfo(selectedNode, cancellationToken).Symbol
+                ?? semanticModel.GetDeclaredSymbol(selectedNode, cancellationToken);
+
+            if (selectedSymbol is null)
+            {
+                var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
+
+                // If the node is an argument it's possible that it's just 
+                // an identifier in the expression. If so, then grab the symbol
+                // for that node instead of the argument. 
+                // EX: MyMethodCall($$x, y) should get the identifier x and
+                // the symbol for that identifier
+                if (syntaxFacts.IsArgument(selectedNode))
+                {
+                    selectedNode = syntaxFacts.GetExpressionOfArgument(selectedNode)!;
+                    selectedSymbol = semanticModel.GetSymbolInfo(selectedNode, cancellationToken).Symbol;
+                }
+            }
+
+            return (selectedSymbol, selectedNode);
+        }
+
+        private static async Task TrackVariableDefinitionsAsync(ISymbol symbol, OperationCollector collector, CancellationToken cancellationToken)
+        {
+            foreach (var definitionLocation in symbol.Locations)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (definitionLocation is not { SourceTree: not null })
+                {
+                    continue;
+                }
+
+                var node = definitionLocation.FindNode(cancellationToken);
+                var document = collector.Solution.GetRequiredDocument(node.SyntaxTree);
+                var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+
+                var operation = semanticModel.GetOperation(node, cancellationToken);
+
+                var declarators = operation switch
+                {
+                    IVariableDeclaratorOperation variableDeclarator => ImmutableArray.Create(variableDeclarator),
+                    IVariableDeclarationOperation variableDeclaration => variableDeclaration.Declarators,
+                    _ => ImmutableArray<IVariableDeclaratorOperation>.Empty
+                };
+
+                foreach (var declarator in declarators)
+                {
+                    var initializer = declarator.GetVariableInitializer();
+                    if (initializer is null)
+                    {
+                        continue;
+                    }
+
+                    await collector.VisitAsync(initializer, cancellationToken).ConfigureAwait(false);
+                }
+            }
+        }
+
+        private static async Task<ISymbol?> GetSymbolAsync(ValueTrackedItem? item, Solution solution, CancellationToken cancellationToken)
+        {
+            if (item is null)
+            {
+                return null;
+            }
+
+            var document = solution.GetRequiredDocument(item.DocumentId);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            return item.SymbolKey.Resolve(semanticModel.Compilation, cancellationToken: cancellationToken).Symbol;
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/ValueTracking/ValueTrackingProgressCollector.cs b/src/Features/Core/Portable/ValueTracking/ValueTrackingProgressCollector.cs
new file mode 100644
index 0000000000000..5794dba89218f
--- /dev/null
+++ b/src/Features/Core/Portable/ValueTracking/ValueTrackingProgressCollector.cs
@@ -0,0 +1,52 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.CodeAnalysis.ValueTracking
+{
+    internal class ValueTrackingProgressCollector : IProgress<ValueTrackedItem>
+    {
+        private readonly object _lock = new();
+        private readonly Stack<ValueTrackedItem> _items = new();
+
+        public event EventHandler<ValueTrackedItem>? OnNewItem;
+
+        internal ValueTrackedItem? Parent { get; set; }
+
+        public void Report(ValueTrackedItem item)
+        {
+            lock (_lock)
+            {
+                _items.Push(item);
+            }
+
+            OnNewItem?.Invoke(null, item);
+        }
+
+        public ImmutableArray<ValueTrackedItem> GetItems()
+        {
+            lock (_lock)
+            {
+                return _items.ToImmutableArray();
+            }
+        }
+
+        internal async Task<bool> TryReportAsync(Solution solution, Location location, ISymbol symbol, CancellationToken cancellationToken = default)
+        {
+            var item = await ValueTrackedItem.TryCreateAsync(solution, location, symbol, Parent, cancellationToken).ConfigureAwait(false);
+            if (item is not null)
+            {
+                Report(item);
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/ValueTracking/ValueTrackingService.cs b/src/Features/Core/Portable/ValueTracking/ValueTrackingService.cs
new file mode 100644
index 0000000000000..5b7414919cce7
--- /dev/null
+++ b/src/Features/Core/Portable/ValueTracking/ValueTrackingService.cs
@@ -0,0 +1,108 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Internal.Log;
+using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.ValueTracking
+{
+    [ExportWorkspaceService(typeof(IValueTrackingService)), Shared]
+    internal partial class ValueTrackingService : IValueTrackingService
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public ValueTrackingService()
+        {
+        }
+
+        public async Task<ImmutableArray<ValueTrackedItem>> TrackValueSourceAsync(
+            TextSpan selection,
+            Document document,
+            CancellationToken cancellationToken)
+        {
+            using var logger = Logger.LogBlock(FunctionId.ValueTracking_TrackValueSource, cancellationToken, LogLevel.Information);
+            var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false);
+            if (client != null)
+            {
+                var solution = document.Project.Solution;
+
+                var result = await client.TryInvokeAsync<IRemoteValueTrackingService, ImmutableArray<SerializableValueTrackedItem>>(
+                    solution,
+                    (service, solutionInfo, cancellationToken) => service.TrackValueSourceAsync(solutionInfo, selection, document.Id, cancellationToken),
+                    cancellationToken).ConfigureAwait(false);
+
+                if (!result.HasValue)
+                {
+                    return ImmutableArray<ValueTrackedItem>.Empty;
+                }
+
+                using var _ = PooledObjects.ArrayBuilder<ValueTrackedItem>.GetInstance(out var builder);
+
+                foreach (var item in result.Value)
+                {
+                    var rehydratedItem = await item.RehydrateAsync(document.Project.Solution, cancellationToken).ConfigureAwait(false);
+                    Contract.ThrowIfNull(rehydratedItem);
+                    builder.Add(rehydratedItem);
+                }
+
+                return builder.ToImmutable();
+            }
+
+            var progressTracker = new ValueTrackingProgressCollector();
+            await ValueTracker.TrackValueSourceAsync(selection, document, progressTracker, cancellationToken).ConfigureAwait(false);
+            return progressTracker.GetItems();
+        }
+
+        public async Task<ImmutableArray<ValueTrackedItem>> TrackValueSourceAsync(
+            Solution solution,
+            ValueTrackedItem previousTrackedItem,
+            CancellationToken cancellationToken)
+        {
+            using var logger = Logger.LogBlock(FunctionId.ValueTracking_TrackValueSource, cancellationToken, LogLevel.Information);
+            var project = solution.GetRequiredProject(previousTrackedItem.DocumentId.ProjectId);
+            var client = await RemoteHostClient.TryGetClientAsync(project, cancellationToken).ConfigureAwait(false);
+            if (client != null)
+            {
+                var dehydratedItem = SerializableValueTrackedItem.Dehydrate(solution, previousTrackedItem, cancellationToken);
+                var result = await client.TryInvokeAsync<IRemoteValueTrackingService, ImmutableArray<SerializableValueTrackedItem>>(
+                    solution,
+                    (service, solutionInfo, cancellationToken) => service.TrackValueSourceAsync(solutionInfo, dehydratedItem, cancellationToken),
+                    cancellationToken).ConfigureAwait(false);
+
+                if (!result.HasValue)
+                {
+                    return ImmutableArray<ValueTrackedItem>.Empty;
+                }
+
+                using var _ = PooledObjects.ArrayBuilder<ValueTrackedItem>.GetInstance(out var builder);
+
+                foreach (var item in result.Value)
+                {
+                    var rehydratedItem = await item.RehydrateAsync(solution, cancellationToken).ConfigureAwait(false);
+                    if (rehydratedItem is null)
+                    {
+                        throw new InvalidOperationException();
+                    }
+
+                    builder.Add(rehydratedItem);
+                }
+
+                return builder.ToImmutable();
+            }
+
+            var progressTracker = new ValueTrackingProgressCollector();
+            await ValueTracker.TrackValueSourceAsync(solution, previousTrackedItem, progressTracker, cancellationToken).ConfigureAwait(false);
+            return progressTracker.GetItems();
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/Workspace/CompileTimeSolutionProvider.cs b/src/Features/Core/Portable/Workspace/CompileTimeSolutionProvider.cs
index e4de0f1091164..e59ec843df733 100644
--- a/src/Features/Core/Portable/Workspace/CompileTimeSolutionProvider.cs
+++ b/src/Features/Core/Portable/Workspace/CompileTimeSolutionProvider.cs
@@ -79,7 +79,7 @@ public Solution GetCompileTimeSolution(Solution designTimeSolution)
                 {
                     var anyConfigs = false;
 
-                    foreach (var configState in projectState.AnalyzerConfigDocumentStates.States)
+                    foreach (var (_, configState) in projectState.AnalyzerConfigDocumentStates.States)
                     {
                         if (IsRazorAnalyzerConfig(configState))
                         {
@@ -91,7 +91,7 @@ public Solution GetCompileTimeSolution(Solution designTimeSolution)
                     // only remove design-time only documents when source-generated ones replace them
                     if (anyConfigs)
                     {
-                        foreach (var documentState in projectState.DocumentStates.States)
+                        foreach (var (_, documentState) in projectState.DocumentStates.States)
                         {
                             if (documentState.Attributes.DesignTimeOnly)
                             {
diff --git a/src/Features/Core/Portable/Workspace/ProjectCacheService.SimpleMRUCache.cs b/src/Features/Core/Portable/Workspace/ProjectCacheService.SimpleMRUCache.cs
index 0121f4f09e907..ed90a6a80e861 100644
--- a/src/Features/Core/Portable/Workspace/ProjectCacheService.SimpleMRUCache.cs
+++ b/src/Features/Core/Portable/Workspace/ProjectCacheService.SimpleMRUCache.cs
@@ -93,9 +93,9 @@ private class ImplicitCacheMonitor : IdleProcessor
             private readonly ProjectCacheService _owner;
             private readonly SemaphoreSlim _gate;
 
-            public ImplicitCacheMonitor(ProjectCacheService owner, int backOffTimeSpanInMS)
+            public ImplicitCacheMonitor(ProjectCacheService owner, TimeSpan backOffTimeSpan)
                 : base(AsynchronousOperationListenerProvider.NullListener,
-                       backOffTimeSpanInMS,
+                       backOffTimeSpan,
                        CancellationToken.None)
             {
                 _owner = owner;
@@ -106,7 +106,7 @@ public ImplicitCacheMonitor(ProjectCacheService owner, int backOffTimeSpanInMS)
 
             protected override Task ExecuteAsync()
             {
-                _owner.ClearExpiredImplicitCache(DateTime.UtcNow - TimeSpan.FromMilliseconds(BackOffTimeSpanInMS));
+                _owner.ClearExpiredImplicitCache(DateTime.UtcNow - BackOffTimeSpan);
 
                 return Task.CompletedTask;
             }
diff --git a/src/Features/Core/Portable/Workspace/ProjectCacheService.cs b/src/Features/Core/Portable/Workspace/ProjectCacheService.cs
index 555fffd75022e..dffbc15cc5c51 100644
--- a/src/Features/Core/Portable/Workspace/ProjectCacheService.cs
+++ b/src/Features/Core/Portable/Workspace/ProjectCacheService.cs
@@ -34,7 +34,7 @@ internal partial class ProjectCacheService : IProjectCacheHostService
         public ProjectCacheService(Workspace workspace)
             => _workspace = workspace;
 
-        public ProjectCacheService(Workspace workspace, int implicitCacheTimeout)
+        public ProjectCacheService(Workspace workspace, TimeSpan implicitCacheTimeout)
         {
             _workspace = workspace;
 
diff --git a/src/Features/LanguageServer/Protocol/CustomProtocol/FindUsagesLSPContext.cs b/src/Features/LanguageServer/Protocol/CustomProtocol/FindUsagesLSPContext.cs
index b607e5ca7927c..364b2d7e942a5 100644
--- a/src/Features/LanguageServer/Protocol/CustomProtocol/FindUsagesLSPContext.cs
+++ b/src/Features/LanguageServer/Protocol/CustomProtocol/FindUsagesLSPContext.cs
@@ -17,6 +17,7 @@
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.MetadataAsSource;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 using Microsoft.VisualStudio.Text.Adornments;
@@ -72,6 +73,7 @@ public FindUsagesLSPContext(
             Document document,
             int position,
             IMetadataAsSourceFileService metadataAsSourceFileService,
+            IAsynchronousOperationListener asyncListener,
             CancellationToken cancellationToken)
         {
             _progress = progress;
@@ -79,7 +81,7 @@ public FindUsagesLSPContext(
             _position = position;
             _metadataAsSourceFileService = metadataAsSourceFileService;
             _workQueue = new AsyncBatchingWorkQueue<VSReferenceItem>(
-                TimeSpan.FromMilliseconds(500), ReportReferencesAsync, cancellationToken);
+                TimeSpan.FromMilliseconds(500), ReportReferencesAsync, asyncListener, cancellationToken);
         }
 
         // After all definitions/references have been found, wait here until all results have been reported.
@@ -336,11 +338,11 @@ static ClassifiedTextRun[] GetClassifiedTextRuns(
             }
         }
 
-        private Task ReportReferencesAsync(ImmutableArray<VSReferenceItem> referencesToReport, CancellationToken cancellationToken)
+        private ValueTask ReportReferencesAsync(ImmutableArray<VSReferenceItem> referencesToReport, CancellationToken cancellationToken)
         {
             // We can report outside of the lock here since _progress is thread-safe.
             _progress.Report(referencesToReport.ToArray());
-            return Task.CompletedTask;
+            return ValueTaskFactory.CompletedTask;
         }
     }
 }
diff --git a/src/Features/LanguageServer/Protocol/Extensions/Extensions.cs b/src/Features/LanguageServer/Protocol/Extensions/Extensions.cs
index e0092066fe773..f149a00bbba7e 100644
--- a/src/Features/LanguageServer/Protocol/Extensions/Extensions.cs
+++ b/src/Features/LanguageServer/Protocol/Extensions/Extensions.cs
@@ -88,24 +88,31 @@ private static ImmutableArray<Document> FilterDocumentsByClientName(ImmutableArr
             return documents.FindDocumentInProjectContext(documentIdentifier);
         }
 
-        public static T FindDocumentInProjectContext<T>(this ImmutableArray<T> documents, TextDocumentIdentifier documentIdentifier) where T : TextDocument
+        public static Document FindDocumentInProjectContext(this ImmutableArray<Document> documents, TextDocumentIdentifier documentIdentifier)
         {
             if (documents.Length > 1)
             {
                 // We have more than one document; try to find the one that matches the right context
-                if (documentIdentifier is VSTextDocumentIdentifier vsDocumentIdentifier)
+                if (documentIdentifier is VSTextDocumentIdentifier vsDocumentIdentifier && vsDocumentIdentifier.ProjectContext != null)
                 {
-                    if (vsDocumentIdentifier.ProjectContext != null)
-                    {
-                        var projectId = ProtocolConversions.ProjectContextToProjectId(vsDocumentIdentifier.ProjectContext);
-                        var matchingDocument = documents.FirstOrDefault(d => d.Project.Id == projectId);
+                    var projectId = ProtocolConversions.ProjectContextToProjectId(vsDocumentIdentifier.ProjectContext);
+                    var matchingDocument = documents.FirstOrDefault(d => d.Project.Id == projectId);
 
-                        if (matchingDocument != null)
-                        {
-                            return matchingDocument;
-                        }
+                    if (matchingDocument != null)
+                    {
+                        return matchingDocument;
                     }
                 }
+                else
+                {
+                    // We were not passed a project context.  This can happen when the LSP powered NavBar is not enabled.
+                    // This branch should be removed when we're using the LSP based navbar in all scenarios.
+
+                    var solution = documents.First().Project.Solution;
+                    // Lookup which of the linked documents is currently active in the workspace.
+                    var documentIdInCurrentContext = solution.Workspace.GetDocumentIdInCurrentContext(documents.First().Id);
+                    return solution.GetRequiredDocument(documentIdInCurrentContext);
+                }
             }
 
             // We either have only one document or have multiple, but none of them  matched our context. In the
@@ -120,7 +127,7 @@ public static async Task<int> GetPositionFromLinePositionAsync(this TextDocument
             return text.Lines.GetPosition(linePosition);
         }
 
-        public static bool HasVisualStudioLspCapability(this ClientCapabilities clientCapabilities)
+        public static bool HasVisualStudioLspCapability(this ClientCapabilities? clientCapabilities)
         {
             if (clientCapabilities is VSClientCapabilities vsClientCapabilities)
             {
diff --git a/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs b/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs
index 0b463c186d80b..d04e255b610b0 100644
--- a/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs
+++ b/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs
@@ -84,12 +84,12 @@ internal static class ProtocolConversions
             int position,
             CancellationToken cancellationToken)
         {
-            if (context == null)
+            if (context is null)
             {
                 // Some LSP clients don't support sending extra context, so all we can do is invoke
                 return Completion.CompletionTrigger.Invoke;
             }
-            else if (context.TriggerKind == LSP.CompletionTriggerKind.Invoked)
+            else if (context.TriggerKind is LSP.CompletionTriggerKind.Invoked or LSP.CompletionTriggerKind.TriggerForIncompleteCompletions)
             {
                 if (context is not LSP.VSCompletionContext vsCompletionContext)
                 {
@@ -116,7 +116,7 @@ internal static class ProtocolConversions
                         return Completion.CompletionTrigger.Invoke;
                 }
             }
-            else if (context.TriggerKind == LSP.CompletionTriggerKind.TriggerCharacter)
+            else if (context.TriggerKind is LSP.CompletionTriggerKind.TriggerCharacter)
             {
                 Contract.ThrowIfNull(context.TriggerCharacter);
                 Contract.ThrowIfFalse(char.TryParse(context.TriggerCharacter, out var triggerChar));
@@ -640,6 +640,9 @@ public static async Task<DocumentOptionSet> FormattingOptionsToDocumentOptionsAs
         }
 
         public static LSP.MarkupContent GetDocumentationMarkupContent(ImmutableArray<TaggedText> tags, Document document, bool featureSupportsMarkdown)
+            => GetDocumentationMarkupContent(tags, document.Project.Language, featureSupportsMarkdown);
+
+        public static LSP.MarkupContent GetDocumentationMarkupContent(ImmutableArray<TaggedText> tags, string language, bool featureSupportsMarkdown)
         {
             if (!featureSupportsMarkdown)
             {
@@ -657,7 +660,7 @@ public static LSP.MarkupContent GetDocumentationMarkupContent(ImmutableArray<Tag
                 switch (taggedText.Tag)
                 {
                     case TextTags.CodeBlockStart:
-                        var codeBlockLanguageName = GetCodeBlockLanguageName(document);
+                        var codeBlockLanguageName = GetCodeBlockLanguageName(language);
                         builder.Append($"```{codeBlockLanguageName}{Environment.NewLine}");
                         builder.Append(taggedText.Text);
                         isInCodeBlock = true;
@@ -686,13 +689,13 @@ public static LSP.MarkupContent GetDocumentationMarkupContent(ImmutableArray<Tag
                 Value = builder.ToString(),
             };
 
-            static string GetCodeBlockLanguageName(Document document)
+            static string GetCodeBlockLanguageName(string language)
             {
-                return document.Project.Language switch
+                return language switch
                 {
                     (LanguageNames.CSharp) => CSharpMarkdownLanguageName,
                     (LanguageNames.VisualBasic) => VisualBasicMarkdownLanguageName,
-                    _ => throw new InvalidOperationException($"{document.Project.Language} is not supported"),
+                    _ => throw new InvalidOperationException($"{language} is not supported"),
                 };
             }
 
diff --git a/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionHandler.cs
index d7273addb85c6..5478046726b99 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionHandler.cs
@@ -17,6 +17,7 @@
 using Microsoft.CodeAnalysis.LanguageServer.Handler.Completion;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Text.Adornments;
 using Roslyn.Utilities;
@@ -73,27 +74,22 @@ public CompletionHandler(
                 return null;
             }
 
-            var position = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(request.Position), cancellationToken).ConfigureAwait(false);
             var completionOptions = await GetCompletionOptionsAsync(document, cancellationToken).ConfigureAwait(false);
-            var completionService = document.Project.LanguageServices.GetRequiredService<CompletionService>();
-
-            // TO-DO: More LSP.CompletionTriggerKind mappings are required to properly map to Roslyn CompletionTriggerKinds.
-            // https://dev.azure.com/devdiv/DevDiv/_workitems/edit/1178726
-            var completionTrigger = await ProtocolConversions.LSPToRoslynCompletionTriggerAsync(request.Context, document, position, cancellationToken).ConfigureAwait(false);
+            var completionService = document.GetRequiredLanguageService<CompletionService>();
+            var documentText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
 
-            var list = await completionService.GetCompletionsAsync(document, position, completionTrigger, options: completionOptions, cancellationToken: cancellationToken).ConfigureAwait(false);
-            if (list == null || list.Items.IsEmpty || cancellationToken.IsCancellationRequested)
+            var completionListResult = await GetFilteredCompletionListAsync(request, documentText, document, completionOptions, completionService, cancellationToken).ConfigureAwait(false);
+            if (completionListResult == null)
             {
                 return null;
             }
 
+            var (list, isIncomplete, resultId) = completionListResult.Value;
+
             var lspVSClientCapability = context.ClientCapabilities.HasVisualStudioLspCapability() == true;
             var snippetsSupported = context.ClientCapabilities.TextDocument?.Completion?.CompletionItem?.SnippetSupport ?? false;
             var commitCharactersRuleCache = new Dictionary<ImmutableArray<CharacterSetModificationRule>, string[]>(CommitCharacterArrayComparer.Instance);
 
-            // Cache the completion list so we can avoid recomputation in the resolve handler
-            var resultId = _completionListCache.UpdateCache(request.TextDocument, list);
-
             // Feature flag to enable the return of TextEdits instead of InsertTexts (will increase payload size).
             // Flag is defined in VisualStudio\Core\Def\PackageRegistration.pkgdef.
             // We also check against the CompletionOption for test purposes only.
@@ -102,7 +98,6 @@ public CompletionHandler(
             var returnTextEdits = featureFlagService.IsExperimentEnabled(WellKnownExperimentNames.LSPCompletion) ||
                 completionOptions.GetOption(CompletionOptions.ForceRoslynLSPCompletionExperiment, document.Project.Language);
 
-            SourceText? documentText = null;
             TextSpan? defaultSpan = null;
             LSP.Range? defaultRange = null;
             if (returnTextEdits)
@@ -132,15 +127,17 @@ public CompletionHandler(
             {
                 var completionItemResolveData = supportsCompletionListData ? null : completionResolveData;
                 var lspCompletionItem = await CreateLSPCompletionItemAsync(
-                    request, document, item, completionItemResolveData, lspVSClientCapability, completionTrigger, commitCharactersRuleCache,
+                    request, document, item, completionItemResolveData, lspVSClientCapability, commitCharactersRuleCache,
                     completionService, context.ClientName, returnTextEdits, snippetsSupported, stringBuilder, documentText,
                     defaultSpan, defaultRange, cancellationToken).ConfigureAwait(false);
                 lspCompletionItems.Add(lspCompletionItem);
             }
+
             var completionList = new LSP.VSCompletionList
             {
                 Items = lspCompletionItems.ToArray(),
                 SuggestionMode = list.SuggestionModeItem != null,
+                IsIncomplete = isIncomplete,
             };
 
             if (supportsCompletionListData)
@@ -179,7 +176,6 @@ bool IsValidTriggerCharacterForDocument(Document document, char triggerCharacter
                 CompletionItem item,
                 CompletionResolveData? completionResolveData,
                 bool supportsVSExtensions,
-                CompletionTrigger completionTrigger,
                 Dictionary<ImmutableArray<CharacterSetModificationRule>, string[]> commitCharacterRulesCache,
                 CompletionService completionService,
                 string? clientName,
@@ -194,7 +190,7 @@ bool IsValidTriggerCharacterForDocument(Document document, char triggerCharacter
                 if (supportsVSExtensions)
                 {
                     var vsCompletionItem = await CreateCompletionItemAsync<LSP.VSCompletionItem>(
-                        request, document, item, completionResolveData, supportsVSExtensions, completionTrigger, commitCharacterRulesCache,
+                        request, document, item, completionResolveData, supportsVSExtensions, commitCharacterRulesCache,
                         completionService, clientName, returnTextEdits, snippetsSupported, stringBuilder,
                         documentText, defaultSpan, defaultRange, cancellationToken).ConfigureAwait(false);
                     vsCompletionItem.Icon = new ImageElement(item.Tags.GetFirstGlyph().GetImageId());
@@ -203,7 +199,7 @@ bool IsValidTriggerCharacterForDocument(Document document, char triggerCharacter
                 else
                 {
                     var roslynCompletionItem = await CreateCompletionItemAsync<LSP.CompletionItem>(
-                        request, document, item, completionResolveData, supportsVSExtensions, completionTrigger, commitCharacterRulesCache,
+                        request, document, item, completionResolveData, supportsVSExtensions, commitCharacterRulesCache,
                         completionService, clientName, returnTextEdits, snippetsSupported, stringBuilder,
                         documentText, defaultSpan, defaultRange, cancellationToken).ConfigureAwait(false);
                     return roslynCompletionItem;
@@ -216,7 +212,6 @@ static async Task<TCompletionItem> CreateCompletionItemAsync<TCompletionItem>(
                 CompletionItem item,
                 CompletionResolveData? completionResolveData,
                 bool supportsVSExtensions,
-                CompletionTrigger completionTrigger,
                 Dictionary<ImmutableArray<CharacterSetModificationRule>, string[]> commitCharacterRulesCache,
                 CompletionService completionService,
                 string? clientName,
@@ -242,7 +237,7 @@ static async Task<TCompletionItem> CreateCompletionItemAsync<TCompletionItem>(
                     FilterText = item.FilterText,
                     Kind = GetCompletionKind(item.Tags),
                     Data = completionResolveData,
-                    Preselect = item.Rules.SelectionBehavior == CompletionItemSelectionBehavior.HardSelection,
+                    Preselect = ShouldItemBePreselected(item),
                 };
 
                 // Complex text edits (e.g. override and partial method completions) are always populated in the
@@ -401,6 +396,147 @@ static void PromoteCommonCommitCharactersOntoList(LSP.VSCompletionList completio
             }
         }
 
+        private async Task<(CompletionList CompletionList, bool IsIncomplete, long ResultId)?> GetFilteredCompletionListAsync(
+            LSP.CompletionParams request,
+            SourceText sourceText,
+            Document document,
+            OptionSet completionOptions,
+            CompletionService completionService,
+            CancellationToken cancellationToken)
+        {
+            var position = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(request.Position), cancellationToken).ConfigureAwait(false);
+            var completionListSpan = completionService.GetDefaultCompletionListSpan(sourceText, position);
+            var completionTrigger = await ProtocolConversions.LSPToRoslynCompletionTriggerAsync(request.Context, document, position, cancellationToken).ConfigureAwait(false);
+            var isTriggerForIncompleteCompletions = request.Context?.TriggerKind == LSP.CompletionTriggerKind.TriggerForIncompleteCompletions;
+
+            (CompletionList List, long ResultId)? result;
+            if (isTriggerForIncompleteCompletions)
+            {
+                // We don't have access to the original trigger, but we know the completion list is already present.
+                // It is safe to recompute with the invoked trigger as we will get all the items and filter down based on the current trigger.
+                var originalTrigger = new CompletionTrigger(CompletionTriggerKind.Invoke);
+                result = await CalculateListAsync(request, document, position, originalTrigger, completionOptions, completionService, _completionListCache, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                // This is a new completion request, clear out the last result Id for incomplete results.
+                result = await CalculateListAsync(request, document, position, completionTrigger, completionOptions, completionService, _completionListCache, cancellationToken).ConfigureAwait(false);
+            }
+
+            if (result == null)
+            {
+                return null;
+            }
+
+            var resultId = result.Value.ResultId;
+
+            var completionListMaxSize = completionOptions.GetOption(LspOptions.MaxCompletionListSize);
+            var (completionList, isIncomplete) = FilterCompletionList(result.Value.List, completionListMaxSize, completionListSpan, completionTrigger, sourceText, document);
+
+            return (completionList, isIncomplete, resultId);
+        }
+
+        private static async Task<(CompletionList CompletionList, long ResultId)?> CalculateListAsync(
+            LSP.CompletionParams request,
+            Document document,
+            int position,
+            CompletionTrigger completionTrigger,
+            OptionSet completionOptions,
+            CompletionService completionService,
+            CompletionListCache completionListCache,
+            CancellationToken cancellationToken)
+        {
+            var completionList = await completionService.GetCompletionsAsync(document, position, completionTrigger, options: completionOptions, cancellationToken: cancellationToken).ConfigureAwait(false);
+            cancellationToken.ThrowIfCancellationRequested();
+            if (completionList == null || completionList.Items.IsEmpty)
+            {
+                return null;
+            }
+
+            // Cache the completion list so we can avoid recomputation in the resolve handler
+            var resultId = completionListCache.UpdateCache(request.TextDocument, completionList);
+
+            return (completionList, resultId);
+        }
+
+        private static (CompletionList CompletionList, bool IsIncomplete) FilterCompletionList(
+            CompletionList completionList,
+            int completionListMaxSize,
+            TextSpan completionListSpan,
+            CompletionTrigger completionTrigger,
+            SourceText sourceText,
+            Document document)
+        {
+            var filterText = sourceText.GetSubText(completionListSpan).ToString();
+
+            // Use pattern matching to determine which items are most relevant out of the calculated items.
+            using var _ = ArrayBuilder<MatchResult<CompletionItem?>>.GetInstance(out var matchResultsBuilder);
+            var index = 0;
+            var completionHelper = CompletionHelper.GetHelper(document);
+            foreach (var item in completionList.Items)
+            {
+                if (CompletionHelper.TryCreateMatchResult<CompletionItem?>(
+                    completionHelper,
+                    item,
+                    editorCompletionItem: null,
+                    filterText,
+                    completionTrigger.Kind,
+                    GetFilterReason(completionTrigger),
+                    recentItems: ImmutableArray<string>.Empty,
+                    includeMatchSpans: false,
+                    index,
+                    out var matchResult))
+                {
+                    matchResultsBuilder.Add(matchResult);
+                    index++;
+                }
+            }
+
+            // Next, we sort the list based on the pattern matching result.
+            matchResultsBuilder.Sort(MatchResult<CompletionItem?>.SortingComparer);
+
+            // Finally, truncate the list to 1000 items plus any preselected items that occur after the first 1000.
+            var filteredList = matchResultsBuilder
+                .Take(completionListMaxSize)
+                .Concat(matchResultsBuilder.Skip(completionListMaxSize).Where(match => ShouldItemBePreselected(match.RoslynCompletionItem)))
+                .Select(matchResult => matchResult.RoslynCompletionItem)
+                .ToImmutableArray();
+            var newCompletionList = completionList.WithItems(filteredList);
+
+            // Per the LSP spec, the completion list should be marked with isIncomplete = false when further insertions will
+            // not generate any more completion items.  This means that we should be checking if the matchedResults is larger
+            // than the filteredList.  However, the VS client has a bug where they do not properly re-trigger completion
+            // when a character is deleted to go from a complete list back to an incomplete list.
+            // For example, the following scenario.
+            // User types "So" -> server gives subset of items for "So" with isIncomplete = true
+            // User types "m" -> server gives entire set of items for "Som" with isIncomplete = false
+            // User deletes "m" -> client has to remember that "So" results were incomplete and re-request if the user types something else, like "n"
+            //
+            // Currently the VS client does not remember to re-request, so the completion list only ever shows items from "Som"
+            // so we always set the isIncomplete flag to true when the original list size (computed when no filter text was typed) is too large.
+            // VS bug here - https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1335142
+            var isIncomplete = completionList.Items.Length > newCompletionList.Items.Length;
+
+            return (newCompletionList, isIncomplete);
+
+            static CompletionFilterReason GetFilterReason(CompletionTrigger trigger)
+            {
+                return trigger.Kind switch
+                {
+                    CompletionTriggerKind.Insertion => CompletionFilterReason.Insertion,
+                    CompletionTriggerKind.Deletion => CompletionFilterReason.Deletion,
+                    _ => CompletionFilterReason.Other,
+                };
+            }
+        }
+
+        private static bool ShouldItemBePreselected(CompletionItem completionItem)
+        {
+            // An item should be preselcted for LSP when the match priority is preselect and the item is hard selected.
+            // LSP does not support soft preselection, so we do not preselect in that scenario to avoid interfering with typing.
+            return completionItem.Rules.MatchPriority == MatchPriority.Preselect && completionItem.Rules.SelectionBehavior == CompletionItemSelectionBehavior.HardSelection;
+        }
+
         internal static ImmutableHashSet<char> GetTriggerCharacters(CompletionProvider provider)
         {
             if (provider is LSPCompletionProvider lspProvider)
diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
index c2d7c278a07c1..e694e67dabf45 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -100,7 +101,9 @@ private void OnDiagnosticsUpdated(object? sender, DiagnosticsUpdatedArgs updateA
             if (updateArgs.DocumentId == null)
                 return;
 
-            lock (_documentIdToLastResultId)
+            // Ensure we do not clear the cached results while the handler is reading (and possibly then writing)
+            // to the cached results.
+            lock (_gate)
             {
                 // Whenever we hear about changes to a document, drop the data we've stored for it.  We'll recompute it as
                 // necessary on the next request.
@@ -145,7 +148,12 @@ private void OnDiagnosticsUpdated(object? sender, DiagnosticsUpdatedArgs updateA
                     continue;
                 }
 
-                if (DiagnosticsAreUnchanged(documentToPreviousDiagnosticParams, document))
+                if (HaveDiagnosticsChanged(documentToPreviousDiagnosticParams, document, out var newResultId))
+                {
+                    context.TraceInformation($"Diagnostics were changed for document: {document.FilePath}");
+                    progress.Report(await ComputeAndReportCurrentDiagnosticsAsync(context, document, newResultId, cancellationToken).ConfigureAwait(false));
+                }
+                else
                 {
                     context.TraceInformation($"Diagnostics were unchanged for document: {document.FilePath}");
 
@@ -155,11 +163,6 @@ private void OnDiagnosticsUpdated(object? sender, DiagnosticsUpdatedArgs updateA
                     var previousParams = documentToPreviousDiagnosticParams[document];
                     progress.Report(CreateReport(previousParams.TextDocument, diagnostics: null, previousParams.PreviousResultId));
                 }
-                else
-                {
-                    context.TraceInformation($"Diagnostics were changed for document: {document.FilePath}");
-                    await ComputeAndReportCurrentDiagnosticsAsync(context, progress, document, cancellationToken).ConfigureAwait(false);
-                }
             }
 
             // If we had a progress object, then we will have been reporting to that.  Otherwise, take what we've been
@@ -198,10 +201,10 @@ private static Dictionary<Document, DiagnosticParams> GetDocumentToPreviousDiagn
             return result;
         }
 
-        private async Task ComputeAndReportCurrentDiagnosticsAsync(
+        private async Task<TReport> ComputeAndReportCurrentDiagnosticsAsync(
             RequestContext context,
-            BufferedProgress<TReport> progress,
             Document document,
+            string resultId,
             CancellationToken cancellationToken)
         {
             // Being asked about this document for the first time.  Or being asked again and we have different
@@ -229,7 +232,7 @@ private async Task ComputeAndReportCurrentDiagnosticsAsync(
                     result.Add(ConvertDiagnostic(document, text, diagnostic));
             }
 
-            progress.Report(RecordDiagnosticReport(document, result.ToArray()));
+            return CreateReport(ProtocolConversions.DocumentToTextDocumentIdentifier(document), result.ToArray(), resultId);
         }
 
         private void HandleRemovedDocuments(RequestContext context, DiagnosticParams[] previousResults, BufferedProgress<TReport> progress)
@@ -256,30 +259,45 @@ private void HandleRemovedDocuments(RequestContext context, DiagnosticParams[] p
             }
         }
 
-        private bool DiagnosticsAreUnchanged(Dictionary<Document, DiagnosticParams> documentToPreviousDiagnosticParams, Document document)
+        /// <summary>
+        /// Returns true if diagnostics have changed since the last request and if so,
+        /// calculates a new resultId to use for subsequent computation and caches it.
+        /// </summary>
+        /// <param name="documentToPreviousDiagnosticParams">the resultIds the client sent us.</param>
+        /// <param name="document">the document we are currently calculating results for.</param>
+        /// <param name="newResultId">the resultId to report new diagnostics with if changed.</param>
+        private bool HaveDiagnosticsChanged(
+            Dictionary<Document, DiagnosticParams> documentToPreviousDiagnosticParams,
+            Document document,
+            [NotNullWhen(true)] out string? newResultId)
         {
+            // Read and write the cached resultId to _documentIdToLastResultId in a single transaction
+            // to prevent in-between updates to _documentIdToLastResultId triggered by OnDiagnosticsUpdated.
             lock (_gate)
             {
                 var workspace = document.Project.Solution.Workspace;
-                return documentToPreviousDiagnosticParams.TryGetValue(document, out var previousParams) &&
+                if (documentToPreviousDiagnosticParams.TryGetValue(document, out var previousParams) &&
                        _documentIdToLastResultId.TryGetValue((workspace, document.Id), out var lastReportedResultId) &&
-                       lastReportedResultId == previousParams.PreviousResultId;
-            }
-        }
+                       lastReportedResultId == previousParams.PreviousResultId)
+                {
+                    // Our cached resultId for the document matches the resultId the client passed to us.
+                    // This means the diagnostics have not changed and we do not need to re-compute.
+                    newResultId = null;
+                    return false;
+                }
 
-        private TReport RecordDiagnosticReport(Document document, VSDiagnostic[] diagnostics)
-        {
-            lock (_gate)
-            {
                 // Keep track of the diagnostics we reported here so that we can short-circuit producing diagnostics for
                 // the same diagnostic set in the future.  Use a custom result-id per type (doc diagnostics or workspace
                 // diagnostics) so that clients of one don't errantly call into the other.  For example, a client
                 // getting document diagnostics should not ask for workspace diagnostics with the result-ids it got for
                 // doc-diagnostics.  The two systems are different and cannot share results, or do things like report
                 // what changed between each other.
-                var resultId = $"{GetType().Name}:{_nextDocumentResultId++}";
-                _documentIdToLastResultId[(document.Project.Solution.Workspace, document.Id)] = resultId;
-                return CreateReport(ProtocolConversions.DocumentToTextDocumentIdentifier(document), diagnostics, resultId);
+                //
+                // Note that we can safely update the map before computation as any cancellation or exception
+                // during computation means that the client will never recieve this resultId and so cannot ask us for it.
+                newResultId = $"{GetType().Name}:{_nextDocumentResultId++}";
+                _documentIdToLastResultId[(document.Project.Solution.Workspace, document.Id)] = newResultId;
+                return true;
             }
         }
 
diff --git a/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs
index 260d849f4c042..478d32ab93d02 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs
@@ -5,10 +5,12 @@
 using System;
 using System.Collections.Immutable;
 using System.Composition;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.QuickInfo;
@@ -51,44 +53,74 @@ public HoverHandler()
                 return null;
             }
 
-            var hover = await GetHoverAsync(info, document, context.ClientCapabilities, cancellationToken).ConfigureAwait(false);
-            return hover;
+            var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            return await GetHoverAsync(info, text, document.Project.Language, document, context.ClientCapabilities, cancellationToken).ConfigureAwait(false);
+        }
+
+        internal static async Task<Hover?> GetHoverAsync(
+            SemanticModel semanticModel,
+            int position,
+            HostLanguageServices languageServices,
+            CancellationToken cancellationToken)
+        {
+            Debug.Assert(semanticModel.Language == LanguageNames.CSharp || semanticModel.Language == LanguageNames.VisualBasic);
 
-            static async Task<Hover> GetHoverAsync(QuickInfoItem info, Document document, ClientCapabilities clientCapabilities, CancellationToken cancellationToken)
+            // Get the quick info service to compute quick info.
+            // This code path is only invoked for C# and VB, so we can directly cast to QuickInfoServiceWithProviders.
+            var quickInfoService = (QuickInfoServiceWithProviders)languageServices.GetRequiredService<QuickInfoService>();
+            var info = await quickInfoService.GetQuickInfoAsync(languageServices.WorkspaceServices.Workspace, semanticModel, position, cancellationToken).ConfigureAwait(false);
+            if (info == null)
             {
-                var supportsVSExtensions = clientCapabilities.HasVisualStudioLspCapability();
+                return null;
+            }
 
-                var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-                if (supportsVSExtensions)
+            var text = await semanticModel.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            return await GetHoverAsync(info, text, semanticModel.Language, document: null, clientCapabilities: null, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static async Task<Hover> GetHoverAsync(
+            QuickInfoItem info,
+            SourceText text,
+            string language,
+            Document? document,
+            ClientCapabilities? clientCapabilities,
+            CancellationToken cancellationToken)
+        {
+            var supportsVSExtensions = clientCapabilities.HasVisualStudioLspCapability();
+
+            if (supportsVSExtensions)
+            {
+                var context = document != null
+                    ? new IntellisenseQuickInfoBuilderContext(document, threadingContext: null, streamingPresenter: null)
+                    : null;
+                return new VSHover
                 {
-                    return new VSHover
-                    {
-                        Range = ProtocolConversions.TextSpanToRange(info.Span, text),
-                        Contents = new SumType<SumType<string, MarkedString>, SumType<string, MarkedString>[], MarkupContent>(string.Empty),
-                        // Build the classified text without navigation actions - they are not serializable.
-                        // TODO - Switch to markup content once it supports classifications.
-                        // https://devdiv.visualstudio.com/DevDiv/_workitems/edit/918138
-                        RawContent = await IntellisenseQuickInfoBuilder.BuildContentWithoutNavigationActionsAsync(info, document, cancellationToken).ConfigureAwait(false)
-                    };
-                }
-                else
+                    Range = ProtocolConversions.TextSpanToRange(info.Span, text),
+                    Contents = new SumType<SumType<string, MarkedString>, SumType<string, MarkedString>[], MarkupContent>(string.Empty),
+                    // Build the classified text without navigation actions - they are not serializable.
+                    // TODO - Switch to markup content once it supports classifications.
+                    // https://devdiv.visualstudio.com/DevDiv/_workitems/edit/918138
+                    RawContent = await IntellisenseQuickInfoBuilder.BuildContentWithoutNavigationActionsAsync(info, context, cancellationToken).ConfigureAwait(false)
+                };
+            }
+            else
+            {
+                return new Hover
                 {
-                    return new Hover
-                    {
-                        Range = ProtocolConversions.TextSpanToRange(info.Span, text),
-                        Contents = GetContents(info, document, clientCapabilities),
-                    };
-                }
+                    Range = ProtocolConversions.TextSpanToRange(info.Span, text),
+                    Contents = GetContents(info, language, clientCapabilities),
+                };
             }
 
-            static MarkupContent GetContents(QuickInfoItem info, Document document, ClientCapabilities clientCapabilities)
+            // Local functions.
+            static MarkupContent GetContents(QuickInfoItem info, string language, ClientCapabilities? clientCapabilities)
             {
                 var clientSupportsMarkdown = clientCapabilities?.TextDocument?.Hover?.ContentFormat.Contains(MarkupKind.Markdown) == true;
                 // Insert line breaks in between sections to ensure we get double spacing between sections.
                 var tags = info.Sections
                     .SelectMany(section => section.TaggedParts.Add(new TaggedText(TextTags.LineBreak, Environment.NewLine)))
                     .ToImmutableArray();
-                return ProtocolConversions.GetDocumentationMarkupContent(tags, document, clientSupportsMarkdown);
+                return ProtocolConversions.GetDocumentationMarkupContent(tags, language, clientSupportsMarkdown);
             }
         }
     }
diff --git a/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs b/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs
index a1d6b8f3ee1e1..86201184020b4 100644
--- a/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.LanguageServer.CustomProtocol;
 using Microsoft.CodeAnalysis.MetadataAsSource;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 using LSP = Microsoft.VisualStudio.LanguageServer.Protocol;
 
@@ -22,12 +23,16 @@ namespace Microsoft.CodeAnalysis.LanguageServer.Handler
     internal class FindAllReferencesHandler : AbstractStatelessRequestHandler<LSP.ReferenceParams, LSP.ReferenceItem[]?>
     {
         private readonly IMetadataAsSourceFileService _metadataAsSourceFileService;
+        private readonly IAsynchronousOperationListener _asyncListener;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public FindAllReferencesHandler(IMetadataAsSourceFileService metadataAsSourceFileService)
+        public FindAllReferencesHandler(
+            IMetadataAsSourceFileService metadataAsSourceFileService,
+            IAsynchronousOperationListenerProvider asynchronousOperationListenerProvider)
         {
             _metadataAsSourceFileService = metadataAsSourceFileService;
+            _asyncListener = asynchronousOperationListenerProvider.GetListener(FeatureAttribute.LanguageServer);
         }
 
         public override string Method => LSP.Methods.TextDocumentReferencesName;
@@ -54,7 +59,7 @@ public FindAllReferencesHandler(IMetadataAsSourceFileService metadataAsSourceFil
                 ProtocolConversions.PositionToLinePosition(referenceParams.Position), cancellationToken).ConfigureAwait(false);
 
             var findUsagesContext = new FindUsagesLSPContext(
-                progress, document, position, _metadataAsSourceFileService, cancellationToken);
+                progress, document, position, _metadataAsSourceFileService, _asyncListener, cancellationToken);
 
             // Finds the references for the symbol at the specific position in the document, reporting them via streaming to the LSP client.
             await findUsagesService.FindReferencesAsync(document, position, findUsagesContext, cancellationToken).ConfigureAwait(false);
diff --git a/src/Features/LanguageServer/Protocol/Handler/RequestContext.cs b/src/Features/LanguageServer/Protocol/Handler/RequestContext.cs
index c269ebb7446a2..135274386d842 100644
--- a/src/Features/LanguageServer/Protocol/Handler/RequestContext.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/RequestContext.cs
@@ -26,6 +26,7 @@ public static RequestContext Create(
             TextDocumentIdentifier? textDocument,
             string? clientName,
             ILspLogger _logger,
+            RequestTelemetryLogger telemetryLogger,
             ClientCapabilities clientCapabilities,
             ILspWorkspaceRegistrationService lspWorkspaceRegistrationService,
             Dictionary<Workspace, (Solution workspaceSolution, Solution lspSolution)>? solutionCache,
@@ -50,7 +51,7 @@ public static RequestContext Create(
                 // There are multiple possible solutions that we could be interested in, so we need to find the document
                 // first and then get the solution from there. If we're not given a document, this will return the default
                 // solution
-                document = FindDocument(_logger, lspWorkspaceRegistrationService, textDocument, clientName);
+                document = FindDocument(_logger, telemetryLogger, lspWorkspaceRegistrationService, textDocument, clientName);
 
                 if (document is not null)
                 {
@@ -84,7 +85,12 @@ public static RequestContext Create(
             return new RequestContext(lspSolution, _logger.TraceInformation, clientCapabilities, clientName, document, documentChangeTracker);
         }
 
-        private static Document? FindDocument(ILspLogger logger, ILspWorkspaceRegistrationService lspWorkspaceRegistrationService, TextDocumentIdentifier textDocument, string? clientName)
+        private static Document? FindDocument(
+            ILspLogger logger,
+            RequestTelemetryLogger telemetryLogger,
+            ILspWorkspaceRegistrationService lspWorkspaceRegistrationService,
+            TextDocumentIdentifier textDocument,
+            string? clientName)
         {
             logger.TraceInformation($"Finding document corresponding to {textDocument.Uri}");
 
@@ -98,14 +104,7 @@ public static RequestContext Create(
                 {
                     var document = documents.FindDocumentInProjectContext(textDocument);
                     logger.TraceInformation($"Found document in workspace {workspace.Kind}: {document.FilePath}");
-
-                    Logger.Log(FunctionId.FindDocumentInWorkspace, KeyValueLogMessage.Create(LogType.Trace, m =>
-                    {
-                        m["WorkspaceKind"] = workspace.Kind;
-                        m["FoundInWorkspace"] = true;
-                        m["DocumentUriHashCode"] = textDocument.Uri.GetHashCode();
-                    }));
-
+                    telemetryLogger.UpdateFindDocumentTelemetryData(success: true, workspace.Kind);
                     return document;
                 }
             }
@@ -113,12 +112,7 @@ public static RequestContext Create(
             var searchedWorkspaceKinds = string.Join(";", workspaceKinds.ToImmutableAndClear());
             logger.TraceWarning($"No document found after looking in {searchedWorkspaceKinds} workspaces, but request did contain a document uri");
 
-            Logger.Log(FunctionId.FindDocumentInWorkspace, KeyValueLogMessage.Create(LogType.Trace, m =>
-            {
-                m["AvailableWorkspaceKinds"] = searchedWorkspaceKinds;
-                m["FoundInWorkspace"] = false;
-                m["DocumentUriHashCode"] = textDocument.Uri.GetHashCode();
-            }));
+            telemetryLogger.UpdateFindDocumentTelemetryData(success: false, workspaceKind: null);
 
             return null;
         }
diff --git a/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.RequestTelemetryLogger.cs b/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.RequestTelemetryLogger.cs
index ac02a539e0d4a..e7eab26087ea7 100644
--- a/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.RequestTelemetryLogger.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.RequestTelemetryLogger.cs
@@ -1,9 +1,11 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using Microsoft.CodeAnalysis.Internal.Log;
 
@@ -42,10 +44,13 @@ internal class RequestTelemetryLogger : IDisposable
             /// </summary>
             private readonly ConcurrentDictionary<string, Counter> _requestCounters;
 
+            private readonly LogAggregator _findDocumentResults;
+
             public RequestTelemetryLogger(string serverTypeName)
             {
                 _serverTypeName = serverTypeName;
-                _requestCounters = new ConcurrentDictionary<string, Counter>();
+                _requestCounters = new();
+                _findDocumentResults = new();
 
                 // Buckets queued duration into 10ms buckets with the last bucket starting at 1000ms.
                 // Queue times are relatively short and fall under 50ms, so tracking past 1000ms is not useful.
@@ -56,7 +61,21 @@ public RequestTelemetryLogger(string serverTypeName)
                 _requestDurationLogAggregator = new HistogramLogAggregator(bucketSize: 1, maxBucketValue: 40);
             }
 
-            public void UpdateTelemetryData(string methodName, TimeSpan queuedDuration, TimeSpan requestDuration, Result result)
+            public void UpdateFindDocumentTelemetryData(bool success, string? workspaceKind)
+            {
+                var workspaceKindTelemetryProperty = success ? workspaceKind : "Failed";
+
+                if (workspaceKindTelemetryProperty != null)
+                {
+                    _findDocumentResults.IncreaseCount(workspaceKindTelemetryProperty);
+                }
+            }
+
+            public void UpdateTelemetryData(
+                string methodName,
+                TimeSpan queuedDuration,
+                TimeSpan requestDuration,
+                Result result)
             {
                 // Find the bucket corresponding to the queued duration and update the count of durations in that bucket.
                 // This is not broken down per method as time in queue is not specific to an LSP method.
@@ -121,6 +140,16 @@ public void Dispose()
                     }));
                 }
 
+                Logger.Log(FunctionId.LSP_FindDocumentInWorkspace, KeyValueLogMessage.Create(LogType.Trace, m =>
+                {
+                    m["server"] = _serverTypeName;
+                    foreach (var kvp in _findDocumentResults)
+                    {
+                        var info = kvp.Key.ToString();
+                        m[info] = kvp.Value.GetCount();
+                    }
+                }));
+
                 // Clear telemetry we've published in case dispose is called multiple times.
                 _requestCounters.Clear();
                 _queuedDurationLogAggregator = null;
diff --git a/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.cs b/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.cs
index a0bb3496df8ec..ac32aae98a1ad 100644
--- a/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.cs
@@ -288,6 +288,7 @@ private RequestContext CreateRequestContext(QueueItem queueItem, out Workspace w
                 queueItem.TextDocument,
                 queueItem.ClientName,
                 _logger,
+                _requestTelemetryLogger,
                 queueItem.ClientCapabilities,
                 _workspaceRegistrationService,
                 _lspSolutionCache,
diff --git a/src/Features/LanguageServer/Protocol/LspOptions.cs b/src/Features/LanguageServer/Protocol/LspOptions.cs
new file mode 100644
index 0000000000000..570fc50bb5d50
--- /dev/null
+++ b/src/Features/LanguageServer/Protocol/LspOptions.cs
@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Text;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Options.Providers;
+
+namespace Microsoft.CodeAnalysis.LanguageServer
+{
+    internal static class LspOptions
+    {
+        private const string LocalRegistryPath = @"Roslyn\Internal\Lsp\";
+
+        /// <summary>
+        /// This sets the max list size we will return in response to a completion request.
+        /// If there are more than this many items, we will set the isIncomplete flag on the returned completion list.
+        /// </summary>
+        public static readonly Option2<int> MaxCompletionListSize = new(nameof(LspOptions), nameof(MaxCompletionListSize), defaultValue: 1000,
+            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(MaxCompletionListSize)));
+    }
+
+    [ExportOptionProvider, Shared]
+    internal class LspOptionsProvider : IOptionProvider
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public LspOptionsProvider()
+        {
+        }
+
+        public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(LspOptions.MaxCompletionListSize);
+    }
+}
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/CodeActions/CodeActionsTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/CodeActions/CodeActionsTests.cs
index 7073c2029d2ab..0a1ea86441648 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/CodeActions/CodeActionsTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/CodeActions/CodeActionsTests.cs
@@ -47,7 +47,7 @@ void M()
                     caretLocation,
                     customTags: new[] { PredefinedCodeRefactoringProviderNames.UseImplicitType }),
                 priority: PriorityLevel.Low,
-                groupName: "Roslyn4",
+                groupName: "Roslyn1",
                 applicableRange: new LSP.Range { Start = new Position { Line = 4, Character = 8 }, End = new Position { Line = 4, Character = 11 } },
                 diagnostics: null);
 
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Completion/CompletionTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Completion/CompletionTests.cs
index 176087b2ee5d7..c7f9d448ed442 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Completion/CompletionTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Completion/CompletionTests.cs
@@ -4,6 +4,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
@@ -94,6 +95,33 @@ void M()
             AssertJsonEquals(expected, results.Items.First());
         }
 
+        [Fact]
+        public async Task TestGetCompletionsTypingAsync()
+        {
+            var markup =
+@"class A
+{
+    void M()
+    {
+        A{|caret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var completionParams = CreateCompletionParams(
+                locations["caret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "A",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+
+            var document = testLspServer.GetCurrentSolution().Projects.First().Documents.First();
+
+            var expected = await CreateCompletionItemAsync(label: "A", kind: LSP.CompletionItemKind.Class, tags: new string[] { "Class", "Internal" },
+                request: completionParams, document: document, commitCharacters: CompletionRules.Default.DefaultCommitCharacters, insertText: "A").ConfigureAwait(false);
+
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            AssertJsonEquals(expected, results.Items.First());
+        }
+
         [Fact]
         public async Task TestGetCompletionsDoesNotIncludeUnimportedTypesAsync()
         {
@@ -544,6 +572,585 @@ void M()
             Assert.All(results.Items, (item) => Assert.True(item.CommitCharacters.Length == 0));
         }
 
+        [Fact]
+        public async Task TestLargeCompletionListIsMarkedIncompleteAsync()
+        {
+            var markup =
+@"using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Configuration;
+using System.Data;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Media;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+class A
+{
+    void M()
+    {
+        T{|caret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var completionParams = CreateCompletionParams(
+                locations["caret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "T",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.Equal(1000, results.Items.Length);
+            Assert.True(results.IsIncomplete);
+        }
+
+        [Fact]
+        public async Task TestIncompleteCompletionListContainsPreselectedItemAsync()
+        {
+            var markup =
+@"using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Configuration;
+using System.Data;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Media;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+class A
+{
+    class W
+    {
+    }
+    void M()
+    {
+        W someW = new {|caret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var caretLocation = locations["caret"].Single();
+
+            var completionParams = CreateCompletionParams(
+                caretLocation,
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: " ",
+                triggerKind: LSP.CompletionTriggerKind.TriggerCharacter);
+
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.Equal(1000, results.Items.Length);
+            Assert.True(results.IsIncomplete);
+            var itemW = results.Items.Single(item => item.Label == "W");
+            Assert.True(itemW.Preselect);
+        }
+
+        [Fact]
+        public async Task TestRequestForIncompleteListIsFilteredDownAsync()
+        {
+            var markup =
+@"using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Configuration;
+using System.Data;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Media;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+class A
+{
+    void M()
+    {
+        T{|caret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var caretLocation = locations["caret"].Single();
+            await testLspServer.OpenDocumentAsync(caretLocation.Uri);
+
+            var completionParams = CreateCompletionParams(
+                caretLocation,
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "T",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.Equal(1000, results.Items.Length);
+            Assert.True(results.IsIncomplete);
+            Assert.Equal("T", results.Items.First().Label);
+
+            await testLspServer.InsertTextAsync(caretLocation.Uri, (caretLocation.Range.End.Line, caretLocation.Range.End.Character, "a"));
+
+            completionParams = CreateCompletionParams(
+                locations["caret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "a",
+                triggerKind: LSP.CompletionTriggerKind.TriggerForIncompleteCompletions);
+
+            results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.True(results.IsIncomplete);
+            Assert.True(results.Items.Length < 1000);
+            Assert.Contains("ta", results.Items.First().Label, StringComparison.OrdinalIgnoreCase);
+        }
+
+        [Fact]
+        public async Task TestIncompleteCompletionListFiltersWithPatternMatchingAsync()
+        {
+            var markup =
+@"using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Configuration;
+using System.Data;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Media;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+class A
+{
+    void M()
+    {
+        T{|caret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var caretLocation = locations["caret"].Single();
+            await testLspServer.OpenDocumentAsync(caretLocation.Uri);
+
+            var completionParams = CreateCompletionParams(
+                caretLocation,
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "T",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.Equal(1000, results.Items.Length);
+            Assert.True(results.IsIncomplete);
+            Assert.Equal("T", results.Items.First().Label);
+
+            await testLspServer.InsertTextAsync(caretLocation.Uri, (caretLocation.Range.End.Line, caretLocation.Range.End.Character, "C"));
+
+            completionParams = CreateCompletionParams(
+                locations["caret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "C",
+                triggerKind: LSP.CompletionTriggerKind.TriggerForIncompleteCompletions);
+
+            results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.True(results.IsIncomplete);
+            Assert.True(results.Items.Length < 1000);
+            Assert.Equal("TaiwanCalendar", results.Items.First().Label);
+        }
+
+        [Fact]
+        public async Task TestIncompleteCompletionListWithDeletionAsync()
+        {
+            var markup =
+@"using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Configuration;
+using System.Data;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Media;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+class A
+{
+    void M()
+    {
+        T{|caret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var caretLocation = locations["caret"].Single();
+            await testLspServer.OpenDocumentAsync(caretLocation.Uri);
+
+            // Insert 'T' to make 'T' and trigger completion.
+            var completionParams = CreateCompletionParams(
+                caretLocation,
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "T",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.Equal(1000, results.Items.Length);
+            Assert.True(results.IsIncomplete);
+            Assert.Equal("T", results.Items.First().Label);
+
+            // Insert 'ask' to make 'Task' and trigger completion.
+            await testLspServer.InsertTextAsync(caretLocation.Uri, (caretLocation.Range.End.Line, caretLocation.Range.End.Character, "ask"));
+            completionParams = CreateCompletionParams(
+                locations["caret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "k",
+                triggerKind: LSP.CompletionTriggerKind.TriggerForIncompleteCompletions);
+            results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.True(results.IsIncomplete);
+            Assert.True(results.Items.Length < 1000);
+            Assert.Equal("Task", results.Items.First().Label);
+
+            // Delete 'ask' to make 'T' and trigger completion on deletion.
+            await testLspServer.DeleteTextAsync(caretLocation.Uri, (caretLocation.Range.End.Line, caretLocation.Range.End.Character, caretLocation.Range.End.Line, caretLocation.Range.End.Character + 3));
+            completionParams = CreateCompletionParams(
+                locations["caret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Deletion,
+                triggerCharacter: "a",
+                triggerKind: LSP.CompletionTriggerKind.TriggerForIncompleteCompletions);
+            results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.True(results.IsIncomplete);
+            Assert.Equal(1000, results.Items.Length);
+            Assert.True(results.IsIncomplete);
+            Assert.Equal("T", results.Items.First().Label);
+
+            // Insert 'i' to make 'Ti' and trigger completion.
+            await testLspServer.InsertTextAsync(caretLocation.Uri, (caretLocation.Range.End.Line, caretLocation.Range.End.Character, "i"));
+            completionParams = CreateCompletionParams(
+                locations["caret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "i",
+                triggerKind: LSP.CompletionTriggerKind.TriggerForIncompleteCompletions);
+            results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.True(results.IsIncomplete);
+            Assert.True(results.Items.Length < 1000);
+            Assert.Equal("Timeout", results.Items.First().Label);
+        }
+
+        [Fact]
+        public async Task TestNewCompletionRequestDoesNotUseIncompleteListAsync()
+        {
+            var markup =
+@"using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Configuration;
+using System.Data;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Media;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+class A
+{
+    void M()
+    {
+        T{|firstCaret:|}
+    }
+
+    void M2()
+    {
+        Console.W{|secondCaret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var firstCaret = locations["firstCaret"].Single();
+            await testLspServer.OpenDocumentAsync(firstCaret.Uri);
+
+            // Make a completion request that returns an incomplete list.
+            var completionParams = CreateCompletionParams(
+                firstCaret,
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "T",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.Equal(1000, results.Items.Length);
+            Assert.True(results.IsIncomplete);
+            Assert.Equal("T", results.Items.First().Label);
+
+            // Make a second completion request, but not for the original incomplete list.
+            completionParams = CreateCompletionParams(
+                locations["secondCaret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "W",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+            results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.False(results.IsIncomplete);
+            Assert.True(results.Items.Length < 1000);
+            Assert.Equal("WindowHeight", results.Items.First().Label);
+        }
+
+        [Fact]
+        public async Task TestRequestForIncompleteListWhenMissingCachedListAsync()
+        {
+            var markup =
+@"using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Configuration;
+using System.Data;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Media;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+class A
+{
+    void M()
+    {
+        Ta{|caret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var caretLocation = locations["caret"].Single();
+
+            var completionParams = CreateCompletionParams(
+                locations["caret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "a",
+                triggerKind: LSP.CompletionTriggerKind.TriggerForIncompleteCompletions);
+
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.True(results.IsIncomplete);
+            Assert.True(results.Items.Length < 1000);
+            Assert.Contains("ta", results.Items.First().Label, StringComparison.OrdinalIgnoreCase);
+        }
+
+        [Fact]
+        public async Task TestRequestForIncompleteListUsesCorrectCachedListAsync()
+        {
+            var markup =
+@"using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Configuration;
+using System.Data;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Media;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+class A
+{
+    void M1()
+    {
+        int Taaa = 1;
+        T{|firstCaret:|}
+    }
+
+    void M2()
+    {
+        int Saaa = 1;
+        {|secondCaret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var firstCaretLocation = locations["firstCaret"].Single();
+            await testLspServer.OpenDocumentAsync(firstCaretLocation.Uri);
+
+            // Create request to on insertion of 'T'
+            var completionParams = CreateCompletionParams(
+                firstCaretLocation,
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "T",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.Equal(1000, results.Items.Length);
+            Assert.True(results.IsIncomplete);
+            Assert.Equal("T", results.Items.First().Label);
+            Assert.Single(results.Items, item => item.Label == "Taaa");
+
+            // Insert 'S' at the second caret
+            var secondCaretLocation = locations["secondCaret"].Single();
+            await testLspServer.InsertTextAsync(secondCaretLocation.Uri, (secondCaretLocation.Range.End.Line, secondCaretLocation.Range.End.Character, "S"));
+
+            // Trigger completion on 'S'
+            var triggerLocation = GetLocationPlusOne(secondCaretLocation);
+            completionParams = CreateCompletionParams(
+                triggerLocation,
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "S",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+            results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.Equal(1000, results.Items.Length);
+            Assert.True(results.IsIncomplete);
+            Assert.Equal("Saaa", results.Items.First().Label);
+
+            // Now type 'a' in M1 after 'T'
+            await testLspServer.InsertTextAsync(firstCaretLocation.Uri, (firstCaretLocation.Range.End.Line, firstCaretLocation.Range.End.Character, "a"));
+
+            // Trigger completion on 'a' (using incomplete as we previously returned incomplete completions from 'T').
+            triggerLocation = GetLocationPlusOne(firstCaretLocation);
+            completionParams = CreateCompletionParams(
+                triggerLocation,
+                invokeKind: LSP.VSCompletionInvokeKind.Typing,
+                triggerCharacter: "a",
+                triggerKind: LSP.CompletionTriggerKind.TriggerForIncompleteCompletions);
+            results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+
+            // Verify we get completions for 'Ta' and not from the 'S' location in M2
+            Assert.True(results.IsIncomplete);
+            Assert.True(results.Items.Length < 1000);
+            Assert.DoesNotContain(results.Items, item => item.Label == "Saaa");
+            Assert.Contains(results.Items, item => item.Label == "Taaa");
+
+            static LSP.Location GetLocationPlusOne(LSP.Location originalLocation)
+            {
+                var newPosition = new LSP.Position { Character = originalLocation.Range.Start.Character + 1, Line = originalLocation.Range.Start.Line };
+                return new LSP.Location
+                {
+                    Uri = originalLocation.Uri,
+                    Range = new LSP.Range { Start = newPosition, End = newPosition }
+                };
+            }
+        }
+
+        [Fact]
+        public async Task TestCompletionRequestRespectsListSizeOptionAsync()
+        {
+            var markup =
+@"class A
+{
+    void M()
+    {
+        {|caret:|}
+    }
+}";
+            using var testLspServer = CreateTestLspServer(markup, out var locations);
+            var completionParams = CreateCompletionParams(
+                locations["caret"].Single(),
+                invokeKind: LSP.VSCompletionInvokeKind.Explicit,
+                triggerCharacter: "\0",
+                triggerKind: LSP.CompletionTriggerKind.Invoked);
+
+            var listMaxSize = 1;
+            testLspServer.TestWorkspace.SetOptions(testLspServer.TestWorkspace.CurrentSolution.Options.WithChangedOption(LspOptions.MaxCompletionListSize, listMaxSize));
+
+            var results = await RunGetCompletionsAsync(testLspServer, completionParams).ConfigureAwait(false);
+            Assert.True(results.IsIncomplete);
+            Assert.Equal(listMaxSize, results.Items.Length);
+        }
+
         private static Task<LSP.CompletionList> RunGetCompletionsAsync(TestLspServer testLspServer, LSP.CompletionParams completionParams)
         {
             var clientCapabilities = new LSP.VSClientCapabilities { SupportsVisualStudioExtensions = true };
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs
index 59e6075127441..4e031801aadc8 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs
@@ -7,11 +7,15 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editor.Test;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.LanguageServer.Handler;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SolutionCrawler;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 using Roslyn.Test.Utilities;
@@ -33,7 +37,7 @@ public async Task TestNoDocumentDiagnosticsForClosedFilesWithFSAOff()
 
             var document = testLspServer.GetCurrentSolution().Projects.Single().Documents.Single();
 
-            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document);
+            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI());
 
             Assert.Empty(results);
         }
@@ -53,7 +57,7 @@ public async Task TestDocumentDiagnosticsForOpenFilesWithFSAOff()
             await OpenDocumentAsync(testLspServer, document);
 
             var results = await RunGetDocumentPullDiagnosticsAsync(
-                testLspServer, testLspServer.GetCurrentSolution().Projects.Single().Documents.Single());
+                testLspServer, document.GetURI());
 
             Assert.Equal("CS1513", results.Single().Diagnostics.Single().Code);
         }
@@ -72,11 +76,50 @@ public async Task TestNoDocumentDiagnosticsForOpenFilesWithFSAOffIfInPushMode()
 
             await OpenDocumentAsync(testLspServer, document);
 
-            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document);
+            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI());
 
             Assert.Empty(results.Single().Diagnostics);
         }
 
+        [Fact]
+        public async Task TestNoDocumentDiagnosticsForOpenFilesIfDefaultAndFeatureFlagOff()
+        {
+            var markup =
+@"class A {";
+            using var testLspServer = CreateTestWorkspaceWithDiagnostics(markup, BackgroundAnalysisScope.OpenFilesAndProjects, DiagnosticMode.Default);
+
+            // Calling GetTextBuffer will effectively open the file.
+            testLspServer.TestWorkspace.Documents.Single().GetTextBuffer();
+            var document = testLspServer.GetCurrentSolution().Projects.Single().Documents.Single();
+            await OpenDocumentAsync(testLspServer, document);
+
+            // Ensure we get no diagnostics when feature flag is off.
+            var testExperimentationService = (TestExperimentationService)testLspServer.TestWorkspace.Services.GetRequiredService<IExperimentationService>();
+            testExperimentationService.SetExperimentOption(WellKnownExperimentNames.LspPullDiagnosticsFeatureFlag, false);
+
+            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI());
+            Assert.Empty(results.Single().Diagnostics);
+        }
+
+        [Fact]
+        public async Task TestDocumentDiagnosticsForOpenFilesIfDefaultAndFeatureFlagOn()
+        {
+            var markup =
+@"class A {";
+            using var testLspServer = CreateTestWorkspaceWithDiagnostics(markup, BackgroundAnalysisScope.OpenFilesAndProjects, DiagnosticMode.Default);
+
+            // Calling GetTextBuffer will effectively open the file.
+            testLspServer.TestWorkspace.Documents.Single().GetTextBuffer();
+            var document = testLspServer.GetCurrentSolution().Projects.Single().Documents.Single();
+            await OpenDocumentAsync(testLspServer, document);
+
+            var testExperimentationService = (TestExperimentationService)testLspServer.TestWorkspace.Services.GetRequiredService<IExperimentationService>();
+            testExperimentationService.SetExperimentOption(WellKnownExperimentNames.LspPullDiagnosticsFeatureFlag, true);
+
+            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI());
+            Assert.Equal("CS1513", results.Single().Diagnostics.Single().Code);
+        }
+
         [Fact]
         public async Task TestDocumentDiagnosticsForRemovedDocument()
         {
@@ -98,7 +141,7 @@ public async Task TestDocumentDiagnosticsForRemovedDocument()
             await WaitForDiagnosticsAsync(workspace);
             var results = await testLspServer.ExecuteRequestAsync<DocumentDiagnosticsParams, DiagnosticReport[]>(
                 MSLSPMethods.DocumentPullDiagnosticName,
-                CreateDocumentDiagnosticParams(document),
+                CreateDocumentDiagnosticParams(document.GetURI()),
                 new LSP.ClientCapabilities(),
                 clientName: null,
                 CancellationToken.None);
@@ -136,13 +179,13 @@ public async Task TestNoChangeIfDocumentDiagnosticsCalledTwice()
 
             await OpenDocumentAsync(testLspServer, document);
 
-            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document);
+            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI());
 
             Assert.Equal("CS1513", results.Single().Diagnostics.Single().Code);
 
             var resultId = results.Single().ResultId;
             results = await RunGetDocumentPullDiagnosticsAsync(
-                testLspServer, testLspServer.GetCurrentSolution().Projects.Single().Documents.Single(), previousResultId: resultId);
+                testLspServer, document.GetURI(), previousResultId: resultId);
 
             Assert.Null(results.Single().Diagnostics);
             Assert.Equal(resultId, results.Single().ResultId);
@@ -162,13 +205,13 @@ public async Task TestDocumentDiagnosticsRemovedAfterErrorIsFixed()
 
             await OpenDocumentAsync(testLspServer, document);
 
-            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document);
+            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI());
 
             Assert.Equal("CS1513", results[0].Diagnostics.Single().Code);
 
             await InsertTextAsync(testLspServer, document, buffer.CurrentSnapshot.Length, "}");
 
-            results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, testLspServer.GetCurrentSolution().Projects.Single().Documents.Single());
+            results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI());
 
             Assert.Empty(results[0].Diagnostics);
         }
@@ -186,7 +229,7 @@ public async Task TestDocumentDiagnosticsRemainAfterErrorIsNotFixed()
             var document = testLspServer.GetCurrentSolution().Projects.Single().Documents.Single();
 
             await OpenDocumentAsync(testLspServer, document);
-            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document);
+            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI());
 
             Assert.Equal("CS1513", results[0].Diagnostics.Single().Code);
             Assert.Equal(new Position { Line = 0, Character = 9 }, results[0].Diagnostics.Single().Range.Start);
@@ -195,7 +238,7 @@ public async Task TestDocumentDiagnosticsRemainAfterErrorIsNotFixed()
             await InsertTextAsync(testLspServer, document, position: 0, text: " ");
 
             results = await RunGetDocumentPullDiagnosticsAsync(
-                testLspServer, testLspServer.GetCurrentSolution().Projects.Single().Documents.Single(),
+                testLspServer, document.GetURI(),
                 previousResultId: results[0].ResultId);
 
             Assert.Equal("CS1513", results[0].Diagnostics.Single().Code);
@@ -211,61 +254,12 @@ private static async Task InsertTextAsync(
             var sourceText = await document.GetTextAsync();
             var lineInfo = sourceText.Lines.GetLinePositionSpan(new TextSpan(position, 0));
 
-            await testLspServer.ExecuteRequestAsync<DidChangeTextDocumentParams, object>(
-                Methods.TextDocumentDidChangeName,
-                new DidChangeTextDocumentParams
-                {
-                    TextDocument = ProtocolConversions.DocumentToVersionedTextDocumentIdentifier(document),
-                    ContentChanges = new TextDocumentContentChangeEvent[]
-                    {
-                        new TextDocumentContentChangeEvent
-                        {
-                            Range = new LSP.Range
-                            {
-                                Start = ProtocolConversions.LinePositionToPosition(lineInfo.Start),
-                                End  =ProtocolConversions.LinePositionToPosition(lineInfo.End),
-                            },
-                            Text = text,
-                        },
-                    },
-                },
-                new LSP.ClientCapabilities(),
-                clientName: null,
-                CancellationToken.None);
+            await testLspServer.InsertTextAsync(document.GetURI(), (lineInfo.Start.Line, lineInfo.Start.Character, text));
         }
 
-        private static async Task OpenDocumentAsync(TestLspServer testLspServer, Document document)
-        {
-            await testLspServer.ExecuteRequestAsync<DidOpenTextDocumentParams, object>(
-                Methods.TextDocumentDidOpenName,
-                new DidOpenTextDocumentParams
-                {
-                    TextDocument = new TextDocumentItem
-                    {
-                        Uri = document.GetURI(),
-                        Text = document.GetTextSynchronously(CancellationToken.None).ToString(),
-                    }
-                },
-                new LSP.ClientCapabilities(),
-                clientName: null,
-                CancellationToken.None);
-        }
+        private static Task OpenDocumentAsync(TestLspServer testLspServer, Document document) => testLspServer.OpenDocumentAsync(document.GetURI());
 
-        private static async Task CloseDocumentAsync(TestLspServer testLspServer, Document document)
-        {
-            await testLspServer.ExecuteRequestAsync<DidCloseTextDocumentParams, object>(
-                Methods.TextDocumentDidCloseName,
-                new DidCloseTextDocumentParams
-                {
-                    TextDocument = new TextDocumentIdentifier
-                    {
-                        Uri = document.GetURI(),
-                    }
-                },
-                new LSP.ClientCapabilities(),
-                clientName: null,
-                CancellationToken.None);
-        }
+        private static Task CloseDocumentAsync(TestLspServer testLspServer, Document document) => testLspServer.CloseDocumentAsync(document.GetURI());
 
         [Fact]
         public async Task TestStreamingDocumentDiagnostics()
@@ -282,12 +276,56 @@ public async Task TestStreamingDocumentDiagnostics()
             await OpenDocumentAsync(testLspServer, document);
 
             var progress = BufferedProgress.Create<DiagnosticReport>(null);
-            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, testLspServer.GetCurrentSolution().Projects.Single().Documents.Single(), progress: progress);
+            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI(), progress: progress);
 
             Assert.Null(results);
             Assert.Equal("CS1513", progress.GetValues()!.Single().Diagnostics.Single().Code);
         }
 
+        [Fact]
+        public async Task TestDocumentDiagnosticsForOpenFilesUsesActiveContext()
+        {
+            var documentText =
+@"#if ONE
+class A {
+#endif
+class B {";
+            var workspaceXml =
+@$"<Workspace>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj1"" PreprocessorSymbols=""ONE"">
+        <Document FilePath=""C:\C.cs"">{documentText}</Document>
+    </Project>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj2"">
+        <Document IsLinkFile=""true"" LinkFilePath=""C:\C.cs"" LinkAssemblyName=""CSProj1"">{documentText}</Document>
+    </Project>
+</Workspace>";
+
+            using var testLspServer = CreateTestWorkspaceFromXml(workspaceXml, BackgroundAnalysisScope.OpenFilesAndProjects);
+
+            var csproj1Document = testLspServer.GetCurrentSolution().Projects.Where(p => p.Name == "CSProj1").Single().Documents.First();
+            var csproj2Document = testLspServer.GetCurrentSolution().Projects.Where(p => p.Name == "CSProj2").Single().Documents.First();
+
+            // Open either of the documents via LSP, we're tracking the URI and text.
+            await OpenDocumentAsync(testLspServer, csproj1Document);
+
+            // This opens all documents in the workspace and ensures buffers are created.
+            testLspServer.TestWorkspace.GetTestDocument(csproj1Document.Id).GetTextBuffer();
+
+            // Set CSProj2 as the active context and get diagnostics.
+            testLspServer.TestWorkspace.SetDocumentContext(csproj2Document.Id);
+            var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, csproj2Document.GetURI());
+            Assert.Equal("CS1513", results.Single().Diagnostics.Single().Code);
+            var vsDiagnostic = (LSP.VSDiagnostic)results.Single().Diagnostics.Single();
+            Assert.Equal("CSProj2", vsDiagnostic.Projects.Single().ProjectName);
+
+            // Set CSProj1 as the active context and get diagnostics.
+            testLspServer.TestWorkspace.SetDocumentContext(csproj1Document.Id);
+            results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, csproj1Document.GetURI());
+            Assert.Equal(2, results.Single().Diagnostics!.Length);
+            Assert.All(results.Single().Diagnostics, d => Assert.Equal("CS1513", d.Code));
+            Assert.All(results.Single().Diagnostics, d => Assert.Equal("CSProj1", ((VSDiagnostic)d).Projects.Single().ProjectName));
+        }
+
         #endregion
 
         #region Workspace Diagnostics
@@ -488,7 +526,7 @@ public async Task TestStreamingWorkspaceDiagnostics()
 
         private static async Task<DiagnosticReport[]> RunGetDocumentPullDiagnosticsAsync(
             TestLspServer testLspServer,
-            Document document,
+            Uri uri,
             string? previousResultId = null,
             IProgress<DiagnosticReport[]>? progress = null)
         {
@@ -496,7 +534,7 @@ private static async Task<DiagnosticReport[]> RunGetDocumentPullDiagnosticsAsync
 
             var result = await testLspServer.ExecuteRequestAsync<DocumentDiagnosticsParams, DiagnosticReport[]>(
                 MSLSPMethods.DocumentPullDiagnosticName,
-                CreateDocumentDiagnosticParams(document, previousResultId, progress),
+                CreateDocumentDiagnosticParams(uri, previousResultId, progress),
                 new LSP.ClientCapabilities(),
                 clientName: null,
                 CancellationToken.None);
@@ -531,13 +569,13 @@ private static async Task WaitForDiagnosticsAsync(TestWorkspace workspace)
         }
 
         private static DocumentDiagnosticsParams CreateDocumentDiagnosticParams(
-            Document document,
+            Uri uri,
             string? previousResultId = null,
             IProgress<DiagnosticReport[]>? progress = null)
         {
             return new DocumentDiagnosticsParams
             {
-                TextDocument = ProtocolConversions.DocumentToTextDocumentIdentifier(document),
+                TextDocument = new LSP.TextDocumentIdentifier { Uri = uri },
                 PreviousResultId = previousResultId,
                 PartialResultToken = progress,
             };
@@ -555,26 +593,36 @@ private static WorkspaceDocumentDiagnosticsParams CreateWorkspaceDiagnosticParam
         }
 
         private TestLspServer CreateTestWorkspaceWithDiagnostics(string markup, BackgroundAnalysisScope scope, bool pullDiagnostics = true)
+            => CreateTestWorkspaceWithDiagnostics(markup, scope, pullDiagnostics ? DiagnosticMode.Pull : DiagnosticMode.Push);
+
+        private TestLspServer CreateTestWorkspaceWithDiagnostics(string markup, BackgroundAnalysisScope scope, DiagnosticMode mode)
         {
             var testLspServer = CreateTestLspServer(markup, out _);
-            InitializeDiagnostics(scope, testLspServer.TestWorkspace, pullDiagnostics);
+            InitializeDiagnostics(scope, testLspServer.TestWorkspace, mode);
+            return testLspServer;
+        }
+
+        private TestLspServer CreateTestWorkspaceFromXml(string xmlMarkup, BackgroundAnalysisScope scope, bool pullDiagnostics = true)
+        {
+            var testLspServer = CreateXmlTestLspServer(xmlMarkup, out _);
+            InitializeDiagnostics(scope, testLspServer.TestWorkspace, pullDiagnostics ? DiagnosticMode.Pull : DiagnosticMode.Push);
             return testLspServer;
         }
 
         private TestLspServer CreateTestWorkspaceWithDiagnostics(string[] markups, BackgroundAnalysisScope scope, bool pullDiagnostics = true)
         {
             var testLspServer = CreateTestLspServer(markups, out _);
-            InitializeDiagnostics(scope, testLspServer.TestWorkspace, pullDiagnostics);
+            InitializeDiagnostics(scope, testLspServer.TestWorkspace, pullDiagnostics ? DiagnosticMode.Pull : DiagnosticMode.Push);
             return testLspServer;
         }
 
-        private static void InitializeDiagnostics(BackgroundAnalysisScope scope, TestWorkspace workspace, bool pullDiagnostics)
+        private static void InitializeDiagnostics(BackgroundAnalysisScope scope, TestWorkspace workspace, DiagnosticMode diagnosticMode)
         {
             workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(
                 workspace.Options
                     .WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.CSharp, scope)
                     .WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.VisualBasic, scope)
-                    .WithChangedOption(InternalDiagnosticsOptions.NormalDiagnosticMode, pullDiagnostics ? DiagnosticMode.Pull : DiagnosticMode.Push)));
+                    .WithChangedOption(InternalDiagnosticsOptions.NormalDiagnosticMode, diagnosticMode)));
 
             var analyzerReference = new TestAnalyzerReferenceByLanguage(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
             workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences(new[] { analyzerReference }));
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.LinkedDocuments.cs b/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.LinkedDocuments.cs
index 80ed10165055c..f5cfb03de1ab6 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.LinkedDocuments.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.LinkedDocuments.cs
@@ -24,10 +24,11 @@ public partial class DocumentChangesTests
         [Fact]
         public async Task LinkedDocuments_AllTracked()
         {
+            var documentText = "class C { }";
             var workspaceXml =
-@"<Workspace>
+@$"<Workspace>
     <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj1"">
-        <Document FilePath=""C:\C.cs"">{|caret:|}</Document>
+        <Document FilePath=""C:\C.cs"">{documentText}{{|caret:|}}</Document>
     </Project>
     <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj2"">
         <Document IsLinkFile=""true"" LinkFilePath=""C:\C.cs"" LinkAssemblyName=""CSProj1""></Document>
@@ -37,9 +38,7 @@ public async Task LinkedDocuments_AllTracked()
             using var testLspServer = CreateXmlTestLspServer(workspaceXml, out var locations);
             var caretLocation = locations["caret"].Single();
 
-            var documentText = "class C { }";
-
-            await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(caretLocation, documentText));
+            await DidOpen(testLspServer, caretLocation.Uri);
 
             var trackedDocuments = testLspServer.GetQueueAccessor().GetTrackedTexts();
             Assert.Equal(1, trackedDocuments.Count);
@@ -51,7 +50,7 @@ public async Task LinkedDocuments_AllTracked()
                 Assert.Equal(documentText, document.GetTextSynchronously(CancellationToken.None).ToString());
             }
 
-            await DidClose(testLspServer, CreateDidCloseTextDocumentParams(caretLocation));
+            await DidClose(testLspServer, caretLocation.Uri);
 
             Assert.Empty(testLspServer.GetQueueAccessor().GetTrackedTexts());
         }
@@ -59,10 +58,18 @@ public async Task LinkedDocuments_AllTracked()
         [Fact]
         public async Task LinkedDocuments_AllTextChanged()
         {
+            var initialText =
+@"class A
+{
+    void M()
+    {
+        {|caret:|}
+    }
+}";
             var workspaceXml =
-@"<Workspace>
+@$"<Workspace>
     <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj1"">
-        <Document FilePath=""C:\C.cs"">{|caret:|}</Document>
+        <Document FilePath=""C:\C.cs"">{initialText}</Document>
     </Project>
     <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj2"">
         <Document IsLinkFile=""true"" LinkFilePath=""C:\C.cs"" LinkAssemblyName=""CSProj1""></Document>
@@ -72,14 +79,6 @@ public async Task LinkedDocuments_AllTextChanged()
             using var testLspServer = CreateXmlTestLspServer(workspaceXml, out var locations);
             var caretLocation = locations["caret"].Single();
 
-            var initialText =
-@"class A
-{
-    void M()
-    {
-        
-    }
-}";
             var updatedText =
 @"class A
 {
@@ -89,11 +88,11 @@ void M()
     }
 }";
 
-            await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(caretLocation, initialText));
+            await DidOpen(testLspServer, caretLocation.Uri);
 
             Assert.Equal(1, testLspServer.GetQueueAccessor().GetTrackedTexts().Count);
 
-            await DidChange(testLspServer, CreateDidChangeTextDocumentParams(caretLocation.Uri, (4, 8, "// hi there")));
+            await DidChange(testLspServer, caretLocation.Uri, (4, 8, "// hi there"));
 
             var solution = await GetLSPSolution(testLspServer, caretLocation.Uri);
 
@@ -102,7 +101,7 @@ void M()
                 Assert.Equal(updatedText, document.GetTextSynchronously(CancellationToken.None).ToString());
             }
 
-            await DidClose(testLspServer, CreateDidCloseTextDocumentParams(caretLocation));
+            await DidClose(testLspServer, caretLocation.Uri);
 
             Assert.Empty(testLspServer.GetQueueAccessor().GetTrackedTexts());
         }
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.WithFindAllReferences.cs b/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.WithFindAllReferences.cs
index 8135fa864416b..a492c42a6213b 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.WithFindAllReferences.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.WithFindAllReferences.cs
@@ -28,13 +28,13 @@ void M2()
     }
 }";
 
-            var (testLspServer, locationTyped, documentText) = await GetTestLspServerAndLocationAsync(source);
+            var (testLspServer, locationTyped, _) = await GetTestLspServerAndLocationAsync(source);
 
             using (testLspServer)
             {
                 Assert.Empty(testLspServer.GetQueueAccessor().GetTrackedTexts());
 
-                await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText));
+                await DidOpen(testLspServer, locationTyped.Uri);
 
                 var findResults = await FindAllReferencesHandlerTests.RunFindAllReferencesAsync(testLspServer, locationTyped);
                 Assert.Single(findResults);
@@ -42,7 +42,7 @@ void M2()
                 Assert.Equal("A", findResults[0].ContainingType);
 
                 // Declare a local inside A.M()
-                await DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (5, 0, "var i = someInt + 1;\r\n")));
+                await DidChange(testLspServer, locationTyped.Uri, (5, 0, "var i = someInt + 1;\r\n"));
 
                 findResults = await FindAllReferencesHandlerTests.RunFindAllReferencesAsync(testLspServer, locationTyped);
                 Assert.Equal(2, findResults.Length);
@@ -51,7 +51,7 @@ void M2()
                 Assert.Equal("M", findResults[1].ContainingMember);
 
                 // Declare a field in B
-                await DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (10, 0, "int someInt = A.someInt + 1;\r\n")));
+                await DidChange(testLspServer, locationTyped.Uri, (10, 0, "int someInt = A.someInt + 1;\r\n"));
 
                 findResults = await FindAllReferencesHandlerTests.RunFindAllReferencesAsync(testLspServer, locationTyped);
                 Assert.Equal(3, findResults.Length);
@@ -61,7 +61,7 @@ void M2()
                 Assert.Equal("M", findResults[1].ContainingMember);
 
                 // Declare a local inside B.M2()
-                await DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (13, 0, "var j = someInt + A.someInt;\r\n")));
+                await DidChange(testLspServer, locationTyped.Uri, (13, 0, "var j = someInt + A.someInt;\r\n"));
 
                 findResults = await FindAllReferencesHandlerTests.RunFindAllReferencesAsync(testLspServer, locationTyped);
                 Assert.Equal(4, findResults.Length);
@@ -76,7 +76,7 @@ void M2()
                 // the original state will have been updated by back channels (text buffer sync, file changed on disk, etc.)
                 // This is validating that the above didn't succeed by any means except the FAR handler being passed
                 // the updated document, so if we regress and get lucky, we still know about it.
-                await DidClose(testLspServer, CreateDidCloseTextDocumentParams(locationTyped));
+                await DidClose(testLspServer, locationTyped.Uri);
 
                 findResults = await FindAllReferencesHandlerTests.RunFindAllReferencesAsync(testLspServer, locationTyped);
                 Assert.Single(findResults);
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.cs
index 05d4e0e74a207..1f94bddca85ab 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/DocumentChanges/DocumentChangesTests.cs
@@ -43,19 +43,19 @@ void M()
             {
                 Assert.Empty(testLspServer.GetQueueAccessor().GetTrackedTexts());
 
-                await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText));
+                await DidOpen(testLspServer, locationTyped.Uri);
 
                 Assert.Single(testLspServer.GetQueueAccessor().GetTrackedTexts());
 
                 var document = testLspServer.GetQueueAccessor().GetTrackedTexts().Single();
                 Assert.Equal(documentText, document.ToString());
 
-                await DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (4, 8, "// hi there")));
+                await DidChange(testLspServer, locationTyped.Uri, (4, 8, "// hi there"));
 
                 document = testLspServer.GetQueueAccessor().GetTrackedTexts().Single();
                 Assert.Equal(expected, document.ToString());
 
-                await DidClose(testLspServer, CreateDidCloseTextDocumentParams(locationTyped));
+                await DidClose(testLspServer, locationTyped.Uri);
 
                 Assert.Empty(testLspServer.GetQueueAccessor().GetTrackedTexts());
             }
@@ -76,7 +76,7 @@ void M()
 
             using (testLspServer)
             {
-                await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText));
+                await DidOpen(testLspServer, locationTyped.Uri);
 
                 var document = testLspServer.GetQueueAccessor().GetTrackedTexts().FirstOrDefault();
 
@@ -100,9 +100,9 @@ void M()
 
             using (testLspServer)
             {
-                await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText));
+                await DidOpen(testLspServer, locationTyped.Uri);
 
-                await Assert.ThrowsAsync<InvalidOperationException>(() => DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText)));
+                await Assert.ThrowsAsync<InvalidOperationException>(() => DidOpen(testLspServer, locationTyped.Uri));
             }
         }
 
@@ -121,7 +121,7 @@ void M()
 
             using (testLspServer)
             {
-                await Assert.ThrowsAsync<InvalidOperationException>(() => DidClose(testLspServer, CreateDidCloseTextDocumentParams(locationTyped)));
+                await Assert.ThrowsAsync<InvalidOperationException>(() => DidClose(testLspServer, locationTyped.Uri));
             }
         }
 
@@ -140,7 +140,7 @@ void M()
 
             using (testLspServer)
             {
-                await Assert.ThrowsAsync<InvalidOperationException>(() => DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (0, 0, "goo"))));
+                await Assert.ThrowsAsync<InvalidOperationException>(() => DidChange(testLspServer, locationTyped.Uri, (0, 0, "goo")));
             }
         }
 
@@ -156,13 +156,13 @@ void M()
     }
 }";
 
-            var (testLspServer, locationTyped, documentText) = await GetTestLspServerAndLocationAsync(source);
+            var (testLspServer, locationTyped, _) = await GetTestLspServerAndLocationAsync(source);
 
             using (testLspServer)
             {
-                await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText));
+                await DidOpen(testLspServer, locationTyped.Uri);
 
-                await DidClose(testLspServer, CreateDidCloseTextDocumentParams(locationTyped));
+                await DidClose(testLspServer, locationTyped.Uri);
 
                 Assert.Empty(testLspServer.GetQueueAccessor().GetTrackedTexts());
             }
@@ -188,13 +188,13 @@ void M()
     }
 }";
 
-            var (testLspServer, locationTyped, documentText) = await GetTestLspServerAndLocationAsync(source);
+            var (testLspServer, locationTyped, _) = await GetTestLspServerAndLocationAsync(source);
 
             using (testLspServer)
             {
-                await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText));
+                await DidOpen(testLspServer, locationTyped.Uri);
 
-                await DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (4, 8, "// hi there")));
+                await DidChange(testLspServer, locationTyped.Uri, (4, 8, "// hi there"));
 
                 var document = testLspServer.GetQueueAccessor().GetTrackedTexts().FirstOrDefault();
 
@@ -227,9 +227,9 @@ void M()
 
             using (testLspServer)
             {
-                await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText));
+                await DidOpen(testLspServer, locationTyped.Uri);
 
-                await DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (4, 8, "// hi there")));
+                await DidChange(testLspServer, locationTyped.Uri, (4, 8, "// hi there"));
 
                 var documentTextFromWorkspace = (await testLspServer.GetCurrentSolution().GetDocuments(locationTyped.Uri).Single().GetTextAsync()).ToString();
 
@@ -262,13 +262,13 @@ void M()
     }
 }";
 
-            var (testLspServer, locationTyped, documentText) = await GetTestLspServerAndLocationAsync(source);
+            var (testLspServer, locationTyped, _) = await GetTestLspServerAndLocationAsync(source);
 
             using (testLspServer)
             {
-                await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText));
+                await DidOpen(testLspServer, locationTyped.Uri);
 
-                await DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (4, 8, "// hi there"), (5, 0, "        // this builds on that\r\n")));
+                await DidChange(testLspServer, locationTyped.Uri, (4, 8, "// hi there"), (5, 0, "        // this builds on that\r\n"));
 
                 var document = testLspServer.GetQueueAccessor().GetTrackedTexts().FirstOrDefault();
 
@@ -298,15 +298,15 @@ void M()
     }
 }";
 
-            var (testLspServer, locationTyped, documentText) = await GetTestLspServerAndLocationAsync(source);
+            var (testLspServer, locationTyped, _) = await GetTestLspServerAndLocationAsync(source);
 
             using (testLspServer)
             {
-                await DidOpen(testLspServer, CreateDidOpenTextDocumentParams(locationTyped, documentText));
+                await DidOpen(testLspServer, locationTyped.Uri);
 
-                await DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (4, 8, "// hi there")));
+                await DidChange(testLspServer, locationTyped.Uri, (4, 8, "// hi there"));
 
-                await DidChange(testLspServer, CreateDidChangeTextDocumentParams(locationTyped.Uri, (5, 0, "        // this builds on that\r\n")));
+                await DidChange(testLspServer, locationTyped.Uri, (5, 0, "        // this builds on that\r\n"));
 
                 var document = testLspServer.GetQueueAccessor().GetTrackedTexts().FirstOrDefault();
 
@@ -324,67 +324,11 @@ void M()
             return (testLspServer, locationTyped, documentText.ToString());
         }
 
-        private static async Task DidOpen(TestLspServer testLspServer, LSP.DidOpenTextDocumentParams didOpenParams)
-        {
-            await testLspServer.ExecuteRequestAsync<LSP.DidOpenTextDocumentParams, object>(Methods.TextDocumentDidOpenName,
-                           didOpenParams, new LSP.ClientCapabilities(), null, CancellationToken.None);
-        }
-
-        private static async Task DidChange(TestLspServer testLspServer, LSP.DidChangeTextDocumentParams didChangeParams)
-        {
-            await testLspServer.ExecuteRequestAsync<LSP.DidChangeTextDocumentParams, object>(Methods.TextDocumentDidChangeName,
-                           didChangeParams, new LSP.ClientCapabilities(), null, CancellationToken.None);
-        }
+        private static Task DidOpen(TestLspServer testLspServer, Uri uri) => testLspServer.OpenDocumentAsync(uri);
 
-        private static async Task DidClose(TestLspServer testLspServer, LSP.DidCloseTextDocumentParams didCloseParams)
-        {
-            await testLspServer.ExecuteRequestAsync<LSP.DidCloseTextDocumentParams, object>(Methods.TextDocumentDidCloseName,
-                           didCloseParams, new LSP.ClientCapabilities(), null, CancellationToken.None);
-        }
-
-        private static LSP.DidOpenTextDocumentParams CreateDidOpenTextDocumentParams(LSP.Location location, string source)
-            => new LSP.DidOpenTextDocumentParams()
-            {
-                TextDocument = new TextDocumentItem
-                {
-                    Text = source,
-                    Uri = location.Uri
-                }
-            };
-
-        private static LSP.DidChangeTextDocumentParams CreateDidChangeTextDocumentParams(Uri documentUri, params (int line, int column, string text)[] changes)
-        {
-            var changeEvents = new List<TextDocumentContentChangeEvent>();
-            foreach (var change in changes)
-            {
-                changeEvents.Add(new TextDocumentContentChangeEvent
-                {
-                    Text = change.text,
-                    Range = new LSP.Range
-                    {
-                        Start = new Position(change.line, change.column),
-                        End = new Position(change.line, change.column)
-                    }
-                });
-            }
-
-            return new LSP.DidChangeTextDocumentParams()
-            {
-                TextDocument = new VersionedTextDocumentIdentifier
-                {
-                    Uri = documentUri
-                },
-                ContentChanges = changeEvents.ToArray()
-            };
-        }
+        private static async Task DidChange(TestLspServer testLspServer, Uri uri, params (int line, int column, string text)[] changes)
+            => await testLspServer.InsertTextAsync(uri, changes);
 
-        private static LSP.DidCloseTextDocumentParams CreateDidCloseTextDocumentParams(LSP.Location location)
-           => new LSP.DidCloseTextDocumentParams()
-           {
-               TextDocument = new TextDocumentIdentifier
-               {
-                   Uri = location.Uri
-               }
-           };
+        private static async Task DidClose(TestLspServer testLspServer, Uri uri) => await testLspServer.CloseDocumentAsync(uri);
     }
 }
diff --git a/src/Features/Lsif/Generator/Generator.cs b/src/Features/Lsif/Generator/Generator.cs
index 75a61d2c4ffd2..0e094db7bf6ca 100644
--- a/src/Features/Lsif/Generator/Generator.cs
+++ b/src/Features/Lsif/Generator/Generator.cs
@@ -22,14 +22,34 @@ namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator
 {
     internal sealed class Generator
     {
+        // LSIF generator capabilities. See https://github.com/microsoft/lsif-node/blob/main/protocol/src/protocol.ts#L925 for details.
+        private const bool HoverProvider = true;
+        private const bool DeclarationProvider = false;
+        private const bool DefinitionProvider = true;
+        private const bool ReferencesProvider = true;
+        private const bool TypeDefinitionProvider = false;
+        private const bool DocumentSymbolProvider = false;
+        private const bool FoldingRangeProvider = true;
+        private const bool DiagnosticProvider = false;
+
         private readonly ILsifJsonWriter _lsifJsonWriter;
         private readonly IdFactory _idFactory = new IdFactory();
 
-        public Generator(ILsifJsonWriter lsifJsonWriter)
+        private Generator(ILsifJsonWriter lsifJsonWriter)
         {
             _lsifJsonWriter = lsifJsonWriter;
         }
 
+        public static Generator CreateAndWriteCapabilitiesVertex(ILsifJsonWriter lsifJsonWriter)
+        {
+            var generator = new Generator(lsifJsonWriter);
+            var capabilitiesVertex = new Capabilities(generator._idFactory,
+                HoverProvider, DeclarationProvider, DefinitionProvider, ReferencesProvider,
+                TypeDefinitionProvider, DocumentSymbolProvider, FoldingRangeProvider, DiagnosticProvider);
+            generator._lsifJsonWriter.Write(capabilitiesVertex);
+            return generator;
+        }
+
         public void GenerateForCompilation(Compilation compilation, string projectPath, HostLanguageServices languageServices, OptionSet options)
         {
             var projectVertex = new Graph.LsifProject(kind: GetLanguageKind(compilation.Language), new Uri(projectPath), _idFactory);
@@ -195,6 +215,21 @@ public void GenerateForCompilation(Compilation compilation, string projectPath,
                         var referenceResultsId = symbolResultsTracker.GetResultIdForSymbol(referencedSymbol.OriginalDefinition, Methods.TextDocumentReferencesName, () => new ReferenceResult(idFactory));
                         lsifJsonWriter.Write(new Item(referenceResultsId.As<ReferenceResult, Vertex>(), lazyRangeVertex.Value.GetId(), documentVertex.GetId(), idFactory, property: "references"));
                     }
+
+                    // Write hover information for the symbol, if edge has not already been added.
+                    // 'textDocument/hover' edge goes from the symbol ResultSet vertex to the hover result
+                    // See https://github.com/Microsoft/language-server-protocol/blob/main/indexFormat/specification.md#resultset for an example.
+                    if (symbolResultsTracker.ResultSetNeedsInformationalEdgeAdded(symbolForLinkedResultSet, Methods.TextDocumentHoverName))
+                    {
+                        // TODO: Can we avoid the WaitAndGetResult_CanCallOnBackground call by adding a sync method to compute hover?
+                        var hover = HoverHandler.GetHoverAsync(semanticModel, syntaxToken.SpanStart, languageServices, CancellationToken.None).WaitAndGetResult_CanCallOnBackground(CancellationToken.None);
+                        if (hover != null)
+                        {
+                            var hoverResult = new HoverResult(hover, idFactory);
+                            lsifJsonWriter.Write(hoverResult);
+                            lsifJsonWriter.Write(Edge.Create(Methods.TextDocumentHoverName, symbolForLinkedResultSetId, hoverResult.GetId(), idFactory));
+                        }
+                    }
                 }
             }
 
diff --git a/src/Features/Lsif/Generator/Graph/Capabilities.cs b/src/Features/Lsif/Generator/Graph/Capabilities.cs
new file mode 100644
index 0000000000000..ce8568aa73e39
--- /dev/null
+++ b/src/Features/Lsif/Generator/Graph/Capabilities.cs
@@ -0,0 +1,60 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Newtonsoft.Json;
+
+namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.Graph
+{
+    /// <summary>
+    /// Represents a single Capabilities vertex for serialization. See https://github.com/microsoft/lsif-node/blob/main/protocol/src/protocol.ts#L973 for further details.
+    /// </summary>
+    internal sealed class Capabilities : Vertex
+    {
+        [JsonProperty("hoverProvider")]
+        public bool HoverProvider { get; }
+
+        [JsonProperty("declarationProvider")]
+        public bool DeclarationProvider { get; }
+
+        [JsonProperty("definitionProvider")]
+        public bool DefinitionProvider { get; }
+
+        [JsonProperty("referencesProvider")]
+        public bool ReferencesProvider { get; }
+
+        [JsonProperty("typeDefinitionProvider")]
+        public bool TypeDefinitionProvider { get; }
+
+        [JsonProperty("documentSymbolProvider")]
+        public bool DocumentSymbolProvider { get; }
+
+        [JsonProperty("foldingRangeProvider")]
+        public bool FoldingRangeProvider { get; }
+
+        [JsonProperty("diagnosticProvider")]
+        public bool DiagnosticProvider { get; }
+
+        public Capabilities(
+            IdFactory idFactory,
+            bool hoverProvider,
+            bool declarationProvider,
+            bool definitionProvider,
+            bool referencesProvider,
+            bool typeDefinitionProvider,
+            bool documentSymbolProvider,
+            bool foldingRangeProvider,
+            bool diagnosticProvider)
+            : base(label: "capabilities", idFactory)
+        {
+            HoverProvider = hoverProvider;
+            DeclarationProvider = declarationProvider;
+            DefinitionProvider = definitionProvider;
+            ReferencesProvider = referencesProvider;
+            TypeDefinitionProvider = typeDefinitionProvider;
+            DocumentSymbolProvider = documentSymbolProvider;
+            FoldingRangeProvider = foldingRangeProvider;
+            DiagnosticProvider = diagnosticProvider;
+        }
+    }
+}
diff --git a/src/Features/Lsif/Generator/Graph/HoverResult.cs b/src/Features/Lsif/Generator/Graph/HoverResult.cs
new file mode 100644
index 0000000000000..5731da1bc1b6a
--- /dev/null
+++ b/src/Features/Lsif/Generator/Graph/HoverResult.cs
@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.VisualStudio.LanguageServer.Protocol;
+using Newtonsoft.Json;
+
+namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.Graph
+{
+    /// <summary>
+    /// Represents a foverResult vertex for serialization. See https://github.com/Microsoft/language-server-protocol/blob/main/indexFormat/specification.md#more-about-request-textdocumenthover for further details.
+    /// </summary>
+    internal sealed class HoverResult : Vertex
+    {
+        [JsonProperty("result")]
+        public Hover Result { get; }
+
+        public HoverResult(Hover result, IdFactory idFactory)
+            : base(label: "hoverResult", idFactory)
+        {
+            Result = result;
+        }
+    }
+}
diff --git a/src/Features/Lsif/Generator/Program.cs b/src/Features/Lsif/Generator/Program.cs
index 2e07c00106ed6..119b1ba7e21ae 100644
--- a/src/Features/Lsif/Generator/Program.cs
+++ b/src/Features/Lsif/Generator/Program.cs
@@ -136,7 +136,7 @@ private static async Task GenerateWithMSBuildLocatedAsync(
             var solution = await openAsync(msbuildWorkspace);
 
             await logFile.WriteLineAsync($"Load completed in {solutionLoadStopwatch.Elapsed.ToDisplayString()}.");
-            var lsifGenerator = new Generator(lsifWriter);
+            var lsifGenerator = Generator.CreateAndWriteCapabilitiesVertex(lsifWriter);
 
             var totalTimeInGenerationAndCompilationFetchStopwatch = Stopwatch.StartNew();
             var totalTimeInGenerationPhase = TimeSpan.Zero;
@@ -173,7 +173,7 @@ private static async Task GenerateFromCompilerInvocationAsync(FileInfo compilerI
             await logFile.WriteLineAsync($"Load of the project completed in {compilerInvocationLoadStopwatch.Elapsed.ToDisplayString()}.");
 
             var generationStopwatch = Stopwatch.StartNew();
-            var lsifGenerator = new Generator(lsifWriter);
+            var lsifGenerator = Generator.CreateAndWriteCapabilitiesVertex(lsifWriter);
 
             lsifGenerator.GenerateForCompilation(compilerInvocation.Compilation, compilerInvocation.ProjectFilePath, compilerInvocation.LanguageServices, compilerInvocation.Options);
             await logFile.WriteLineAsync($"Generation for {compilerInvocation.ProjectFilePath} completed in {generationStopwatch.Elapsed.ToDisplayString()}.");
diff --git a/src/Features/Lsif/GeneratorTest/HoverTests.vb b/src/Features/Lsif/GeneratorTest/HoverTests.vb
new file mode 100644
index 0000000000000..f8f4c2488e949
--- /dev/null
+++ b/src/Features/Lsif/GeneratorTest/HoverTests.vb
@@ -0,0 +1,168 @@
+' Licensed to the .NET Foundation under one or more agreements.
+' The .NET Foundation licenses this file to you under the MIT license.
+' See the LICENSE file in the project root for more information.
+
+Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
+Imports Microsoft.CodeAnalysis.Test.Utilities
+Imports Microsoft.VisualStudio.LanguageServer.Protocol
+
+Namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.UnitTests
+    <UseExportProvider>
+    Public NotInheritable Class HoverTests
+        Private Const TestProjectAssemblyName As String = "TestProject"
+
+        <Theory>
+        <InlineData("class [|C|] { string s; }")>
+        <InlineData("class C { void [|M|]() { } }")>
+        <InlineData("class C { string [|s|]; }")>
+        <InlineData("class C { void M(string [|s|]) { M(s); } }")>
+        <InlineData("class C { void M(string s) { string [|local|] = """"; } }")>
+        <InlineData("
+class C
+{
+    /// <summary>Doc Comment</summary>
+    void [|M|]() { }
+}")>
+        Public Async Function TestDefinition(code As String) As Task
+            Dim lsif = Await TestLsifOutput.GenerateForWorkspaceAsync(
+                TestWorkspace.CreateWorkspace(
+                    <Workspace>
+                        <Project Language="C#" AssemblyName=<%= TestProjectAssemblyName %> FilePath="Z:\TestProject.csproj" CommonReferences="true">
+                            <Document Name="A.cs" FilePath="Z:\A.cs">
+                                <%= code %>
+                            </Document>
+                        </Project>
+                    </Workspace>))
+
+            Dim rangeVertex = Await lsif.GetSelectedRangeAsync()
+            Dim resultSetVertex = lsif.GetLinkedVertices(Of Graph.ResultSet)(rangeVertex, "next").Single()
+            Dim hoverVertex = lsif.GetLinkedVertices(Of Graph.HoverResult)(resultSetVertex, Methods.TextDocumentHoverName).SingleOrDefault()
+            Dim hoverMarkupContent = DirectCast(hoverVertex.Result.Contents.Value, MarkupContent)
+
+            Dim expectedHoverContents As String
+            Select Case code
+                Case "class [|C|] { string s; }"
+                    expectedHoverContents = "class C"
+                Case "class C { void [|M|]() { } }"
+                    expectedHoverContents = "void C.M()"
+                Case "class C { string [|s|]; }"
+                    expectedHoverContents = $"({FeaturesResources.field}) string C.s"
+                Case "class C { void M(string [|s|]) { M(s); } }"
+                    expectedHoverContents = $"({FeaturesResources.parameter}) string s"
+                Case "class C { void M(string s) { string [|local|] = """"; } }"
+                    expectedHoverContents = $"({FeaturesResources.local_variable}) string local"
+                Case "
+class C
+{
+    /// <summary>Doc Comment</summary>
+    void [|M|]() { }
+}"
+                    expectedHoverContents = "void C.M()
+Doc Comment"
+                Case Else
+                    Throw TestExceptionUtilities.UnexpectedValue(code)
+            End Select
+
+            Assert.Equal(MarkupKind.PlainText, hoverMarkupContent.Kind)
+            Assert.Equal(expectedHoverContents + Environment.NewLine, hoverMarkupContent.Value)
+        End Function
+
+        <Theory>
+        <InlineData("class C { [|string|] s; }")>
+        <InlineData("class C { void M() { [|M|](); } }")>
+        <InlineData("class C { void M(string s) { M([|s|]); } }")>
+        <InlineData("class C { void M(string s) { string local = """"; M([|local|]); } }")>
+        <InlineData("using [|S|] = System.String;")>
+        <InlineData("class C { [|global|]::System.String s; }")>
+        <InlineData("
+class C
+{
+    /// <see cref=""C.[|M|]()"" />
+    void M() { }
+}")>
+        Public Async Function TestReference(code As String) As Task
+            Dim lsif = Await TestLsifOutput.GenerateForWorkspaceAsync(
+                TestWorkspace.CreateWorkspace(
+                    <Workspace>
+                        <Project Language="C#" AssemblyName=<%= TestProjectAssemblyName %> FilePath="Z:\TestProject.csproj" CommonReferences="true">
+                            <Document Name="A.cs" FilePath="Z:\A.cs">
+                                <%= code %>
+                            </Document>
+                        </Project>
+                    </Workspace>))
+
+            Dim rangeVertex = Await lsif.GetSelectedRangeAsync()
+            Dim resultSetVertex = lsif.GetLinkedVertices(Of Graph.ResultSet)(rangeVertex, "next").Single()
+            Dim hoverVertex = lsif.GetLinkedVertices(Of Graph.HoverResult)(resultSetVertex, Methods.TextDocumentHoverName).SingleOrDefault()
+            Dim hoverMarkupContent = DirectCast(hoverVertex.Result.Contents.Value, MarkupContent)
+
+            Dim expectedHoverContents As String
+            Select Case code
+                Case "class C { [|string|] s; }"
+                    expectedHoverContents = "class System.String"
+                Case "class C { void M() { [|M|](); } }"
+                    expectedHoverContents = "void C.M()"
+                Case "class C { void M(string s) { M([|s|]); } }"
+                    expectedHoverContents = $"({FeaturesResources.parameter}) string s"
+                Case "class C { void M(string s) { string local = """"; M([|local|]); } }"
+                    expectedHoverContents = $"({FeaturesResources.local_variable}) string local"
+                Case "using [|S|] = System.String;"
+                    expectedHoverContents = "class System.String"
+                Case "class C { [|global|]::System.String s; }"
+                    expectedHoverContents = "<global namespace>"
+                Case "
+class C
+{
+    /// <see cref=""C.[|M|]()"" />
+    void M() { }
+}"
+                    expectedHoverContents = "void C.M()"
+                Case Else
+                    Throw TestExceptionUtilities.UnexpectedValue(code)
+            End Select
+
+            Assert.Equal(MarkupKind.PlainText, hoverMarkupContent.Kind)
+            Assert.Equal(expectedHoverContents + Environment.NewLine, hoverMarkupContent.Value)
+        End Function
+
+        <Fact>
+        Public Async Function ToplevelResultsInMultipleFiles() As Task
+            Dim lsif = Await TestLsifOutput.GenerateForWorkspaceAsync(
+                TestWorkspace.CreateWorkspace(
+                    <Workspace>
+                        <Project Language="C#" AssemblyName=<%= TestProjectAssemblyName %> FilePath="Z:\TestProject.csproj" CommonReferences="true">
+                            <Document Name="A.cs" FilePath="Z:\A.cs">
+                                class A { [|string|] s; }
+                            </Document>
+                            <Document Name="B.cs" FilePath="Z:\B.cs">
+                                class B { [|string|] s; }
+                            </Document>
+                            <Document Name="C.cs" FilePath="Z:\C.cs">
+                                class C { [|string|] s; }
+                            </Document>
+                            <Document Name="D.cs" FilePath="Z:\D.cs">
+                                class D { [|string|] s; }
+                            </Document>
+                            <Document Name="E.cs" FilePath="Z:\E.cs">
+                                class E { [|string|] s; }
+                            </Document>
+                        </Project>
+                    </Workspace>))
+
+            Dim hoverVertex As Graph.HoverResult = Nothing
+            For Each rangeVertex In Await lsif.GetSelectedRangesAsync()
+                Dim resultSetVertex = lsif.GetLinkedVertices(Of Graph.ResultSet)(rangeVertex, "next").Single()
+                Dim vertex = lsif.GetLinkedVertices(Of Graph.HoverResult)(resultSetVertex, Methods.TextDocumentHoverName).Single()
+                If hoverVertex Is Nothing Then
+                    hoverVertex = vertex
+                Else
+                    Assert.Same(hoverVertex, vertex)
+                End If
+            Next
+
+            Dim hoverMarkupContent = DirectCast(hoverVertex.Result.Contents.Value, MarkupContent)
+            Assert.Equal(MarkupKind.PlainText, hoverMarkupContent.Kind)
+            Assert.Equal("class System.String" + Environment.NewLine, hoverMarkupContent.Value)
+        End Function
+    End Class
+End Namespace
diff --git a/src/Features/Lsif/GeneratorTest/OutputFormatTests.vb b/src/Features/Lsif/GeneratorTest/OutputFormatTests.vb
index c03e713c7fceb..2ba3059feca06 100644
--- a/src/Features/Lsif/GeneratorTest/OutputFormatTests.vb
+++ b/src/Features/Lsif/GeneratorTest/OutputFormatTests.vb
@@ -25,16 +25,17 @@ Namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.UnitTests
                     </Workspace>), jsonWriter)
 
             AssertEx.EqualOrDiff(
-"{""kind"":""csharp"",""resource"":""file:///Z:/TestProject.csproj"",""id"":1,""type"":""vertex"",""label"":""project""}
-{""kind"":""begin"",""scope"":""project"",""data"":1,""id"":2,""type"":""vertex"",""label"":""$event""}
-{""uri"":""file:///Z:/A.cs"",""languageId"":""csharp"",""id"":3,""type"":""vertex"",""label"":""document""}
-{""kind"":""begin"",""scope"":""document"",""data"":3,""id"":4,""type"":""vertex"",""label"":""$event""}
-{""outV"":3,""inVs"":[],""id"":5,""type"":""edge"",""label"":""contains""}
-{""result"":[],""id"":6,""type"":""vertex"",""label"":""foldingRangeResult""}
-{""outV"":3,""inVs"":[6],""id"":7,""type"":""edge"",""label"":""textDocument/foldingRange""}
-{""kind"":""end"",""scope"":""document"",""data"":3,""id"":8,""type"":""vertex"",""label"":""$event""}
-{""outV"":1,""inVs"":[3],""id"":9,""type"":""edge"",""label"":""contains""}
-{""kind"":""end"",""scope"":""project"",""data"":1,""id"":10,""type"":""vertex"",""label"":""$event""}
+"{""hoverProvider"":true,""declarationProvider"":false,""definitionProvider"":true,""referencesProvider"":true,""typeDefinitionProvider"":false,""documentSymbolProvider"":false,""foldingRangeProvider"":true,""diagnosticProvider"":false,""id"":1,""type"":""vertex"",""label"":""capabilities""}
+{""kind"":""csharp"",""resource"":""file:///Z:/TestProject.csproj"",""id"":2,""type"":""vertex"",""label"":""project""}
+{""kind"":""begin"",""scope"":""project"",""data"":2,""id"":3,""type"":""vertex"",""label"":""$event""}
+{""uri"":""file:///Z:/A.cs"",""languageId"":""csharp"",""id"":4,""type"":""vertex"",""label"":""document""}
+{""kind"":""begin"",""scope"":""document"",""data"":4,""id"":5,""type"":""vertex"",""label"":""$event""}
+{""outV"":4,""inVs"":[],""id"":6,""type"":""edge"",""label"":""contains""}
+{""result"":[],""id"":7,""type"":""vertex"",""label"":""foldingRangeResult""}
+{""outV"":4,""inVs"":[7],""id"":8,""type"":""edge"",""label"":""textDocument/foldingRange""}
+{""kind"":""end"",""scope"":""document"",""data"":4,""id"":9,""type"":""vertex"",""label"":""$event""}
+{""outV"":2,""inVs"":[4],""id"":10,""type"":""edge"",""label"":""contains""}
+{""kind"":""end"",""scope"":""project"",""data"":2,""id"":11,""type"":""vertex"",""label"":""$event""}
 ", stringWriter.ToString())
         End Function
 
@@ -54,80 +55,93 @@ Namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.UnitTests
 
             AssertEx.EqualOrDiff(
     "[
+  {
+    ""hoverProvider"": true,
+    ""declarationProvider"": false,
+    ""definitionProvider"": true,
+    ""referencesProvider"": true,
+    ""typeDefinitionProvider"": false,
+    ""documentSymbolProvider"": false,
+    ""foldingRangeProvider"": true,
+    ""diagnosticProvider"": false,
+    ""id"": 1,
+    ""type"": ""vertex"",
+    ""label"": ""capabilities""
+  },
   {
     ""kind"": ""csharp"",
     ""resource"": ""file:///Z:/TestProject.csproj"",
-    ""id"": 1,
+    ""id"": 2,
     ""type"": ""vertex"",
     ""label"": ""project""
   },
   {
     ""kind"": ""begin"",
     ""scope"": ""project"",
-    ""data"": 1,
-    ""id"": 2,
+    ""data"": 2,
+    ""id"": 3,
     ""type"": ""vertex"",
     ""label"": ""$event""
   },
   {
     ""uri"": ""file:///Z:/A.cs"",
     ""languageId"": ""csharp"",
-    ""id"": 3,
+    ""id"": 4,
     ""type"": ""vertex"",
     ""label"": ""document""
   },
   {
     ""kind"": ""begin"",
     ""scope"": ""document"",
-    ""data"": 3,
-    ""id"": 4,
+    ""data"": 4,
+    ""id"": 5,
     ""type"": ""vertex"",
     ""label"": ""$event""
   },
   {
-    ""outV"": 3,
+    ""outV"": 4,
     ""inVs"": [],
-    ""id"": 5,
+    ""id"": 6,
     ""type"": ""edge"",
     ""label"": ""contains""
   },
   {
     ""result"": [],
-    ""id"": 6,
+    ""id"": 7,
     ""type"": ""vertex"",
     ""label"": ""foldingRangeResult""
   },
   {
-    ""outV"": 3,
+    ""outV"": 4,
     ""inVs"": [
-      6
+      7
     ],
-    ""id"": 7,
+    ""id"": 8,
     ""type"": ""edge"",
     ""label"": ""textDocument/foldingRange""
   },
   {
     ""kind"": ""end"",
     ""scope"": ""document"",
-    ""data"": 3,
-    ""id"": 8,
+    ""data"": 4,
+    ""id"": 9,
     ""type"": ""vertex"",
     ""label"": ""$event""
   },
   {
-    ""outV"": 1,
+    ""outV"": 2,
     ""inVs"": [
-      3
+      4
     ],
-    ""id"": 9,
+    ""id"": 10,
     ""type"": ""edge"",
     ""label"": ""contains""
   },
   {
     ""kind"": ""end"",
     ""scope"": ""project"",
-    ""data"": 1,
-    ""id"": 10,
+    ""data"": 2,
+    ""id"": 11,
     ""type"": ""vertex"",
     ""label"": ""$event""
   }
diff --git a/src/Features/Lsif/GeneratorTest/Utilities/TestLsifOutput.vb b/src/Features/Lsif/GeneratorTest/Utilities/TestLsifOutput.vb
index 3e8f98eab3b61..1c3fe9031bc43 100644
--- a/src/Features/Lsif/GeneratorTest/Utilities/TestLsifOutput.vb
+++ b/src/Features/Lsif/GeneratorTest/Utilities/TestLsifOutput.vb
@@ -27,7 +27,7 @@ Namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.UnitTests.U
         End Function
 
         Public Shared Async Function GenerateForWorkspaceAsync(workspace As TestWorkspace, jsonWriter As ILsifJsonWriter) As Task
-            Dim generator = New Generator(jsonWriter)
+            Dim lsifGenerator = Generator.CreateAndWriteCapabilitiesVertex(jsonWriter)
 
             For Each project In workspace.CurrentSolution.Projects
                 Dim compilation = Await project.GetCompilationAsync()
@@ -35,7 +35,7 @@ Namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.UnitTests.U
                 ' Assert we don't have any errors to prevent any typos in the tests
                 Assert.Empty(compilation.GetDiagnostics().Where(Function(d) d.Severity = DiagnosticSeverity.Error))
 
-                generator.GenerateForCompilation(compilation, project.FilePath, project.LanguageServices, project.Solution.Options)
+                lsifGenerator.GenerateForCompilation(compilation, project.FilePath, project.LanguageServices, project.Solution.Options)
             Next
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/AddImport/VisualBasicAddImportFeatureService.vb b/src/Features/VisualBasic/Portable/AddImport/VisualBasicAddImportFeatureService.vb
index 2ce69719b41d8..fe2a16b3541e2 100644
--- a/src/Features/VisualBasic/Portable/AddImport/VisualBasicAddImportFeatureService.vb
+++ b/src/Features/VisualBasic/Portable/AddImport/VisualBasicAddImportFeatureService.vb
@@ -47,12 +47,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.AddImport
                     If parent Is Nothing Then
                         Return False
                     End If
+
                     Dim method = TryCast(parent.Expression, MemberAccessExpressionSyntax)
                     If method IsNot Nothing Then
                         node = method.Name
                     Else
                         node = parent.Expression
                     End If
+
                     Exit Select
                 Case AddImportDiagnosticIds.BC36719
                     If node.IsKind(SyntaxKind.ObjectCollectionInitializer) Then
@@ -171,8 +173,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.AddImport
                 If simpleName IsNot Nothing Then
                     Return simpleName
                 End If
+
                 qn = TryCast(left, QualifiedNameSyntax)
             End While
+
             Return Nothing
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/CodeFixes/CorrectNextControlVariable/CorrectNextControlVariableCodeFixProvider.vb b/src/Features/VisualBasic/Portable/CodeFixes/CorrectNextControlVariable/CorrectNextControlVariableCodeFixProvider.vb
index 8a0aca04db918..f568245302b73 100644
--- a/src/Features/VisualBasic/Portable/CodeFixes/CorrectNextControlVariable/CorrectNextControlVariableCodeFixProvider.vb
+++ b/src/Features/VisualBasic/Portable/CodeFixes/CorrectNextControlVariable/CorrectNextControlVariableCodeFixProvider.vb
@@ -82,6 +82,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.CorrectNextControlVariabl
                 If forBlock Is Nothing Then
                     Return Nothing
                 End If
+
                 currentNode = forBlock
             Next
 
diff --git a/src/Features/VisualBasic/Portable/CodeFixes/Suppression/VisualBasicSuppressionCodeFixProvider.vb b/src/Features/VisualBasic/Portable/CodeFixes/Suppression/VisualBasicSuppressionCodeFixProvider.vb
index ddd61807cdd2a..0dcdf827df55e 100644
--- a/src/Features/VisualBasic/Portable/CodeFixes/Suppression/VisualBasicSuppressionCodeFixProvider.vb
+++ b/src/Features/VisualBasic/Portable/CodeFixes/Suppression/VisualBasicSuppressionCodeFixProvider.vb
@@ -43,6 +43,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.Suppression
             If SyntaxFacts.GetKeywordKind(text) <> SyntaxKind.None Then
                 text = "[" & text & "]"
             End If
+
             Return New SeparatedSyntaxList(Of IdentifierNameSyntax)().Add(SyntaxFactory.IdentifierName(text))
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/CodeRefactorings/InlineMethod/VisualBasicInlineMethodRefactoringProvider.vb b/src/Features/VisualBasic/Portable/CodeRefactorings/InlineMethod/VisualBasicInlineMethodRefactoringProvider.vb
index 7f318aaa21caf..dff559e23541a 100644
--- a/src/Features/VisualBasic/Portable/CodeRefactorings/InlineMethod/VisualBasicInlineMethodRefactoringProvider.vb
+++ b/src/Features/VisualBasic/Portable/CodeRefactorings/InlineMethod/VisualBasicInlineMethodRefactoringProvider.vb
@@ -42,6 +42,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.InlineTemporary
                     Return throwStatement.Expression
                 End If
             End If
+
             Return Nothing
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/CodeRefactorings/InlineTemporary/InlineTemporaryCodeRefactoringProvider.vb b/src/Features/VisualBasic/Portable/CodeRefactorings/InlineTemporary/InlineTemporaryCodeRefactoringProvider.vb
index 06441b73d0fa9..58aa2cf2e696f 100644
--- a/src/Features/VisualBasic/Portable/CodeRefactorings/InlineTemporary/InlineTemporaryCodeRefactoringProvider.vb
+++ b/src/Features/VisualBasic/Portable/CodeRefactorings/InlineTemporary/InlineTemporaryCodeRefactoringProvider.vb
@@ -463,6 +463,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.InlineTemporary
                                               Return newNode _
                                                   .WithAdditionalAnnotations(ConflictAnnotation.Create(VBFeaturesResources.Conflict_s_detected))
                                           End Function
+
             Return Await inlinedDocument.ReplaceNodesAsync(replacementNodesWithChangedSemantics.Keys, conflictAnnotationAdder, cancellationToken).ConfigureAwait(False)
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImplementsClauseCompletionProvider.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImplementsClauseCompletionProvider.vb
index 61c05e4ef14da..36c327ab2e112 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImplementsClauseCompletionProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImplementsClauseCompletionProvider.vb
@@ -65,10 +65,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
             If methodDeclaration IsNot Nothing Then
                 memberKindKeyword = methodDeclaration.DeclarationKeyword.Kind
             End If
+
             Dim propertyDeclaration = context.TargetToken.GetAncestor(Of PropertyStatementSyntax)()
             If propertyDeclaration IsNot Nothing Then
                 memberKindKeyword = propertyDeclaration.DeclarationKeyword.Kind
             End If
+
             Dim eventDeclaration = context.TargetToken.GetAncestor(Of EventStatementSyntax)()
             If eventDeclaration IsNot Nothing Then
                 memberKindKeyword = eventDeclaration.DeclarationKeyword.Kind
@@ -115,6 +117,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
                 If Not method.ReturnsVoid Then
                     Return memberKindKeyword = SyntaxKind.FunctionKeyword
                 End If
+
                 Return memberKindKeyword = SyntaxKind.SubKeyword
             End If
 
@@ -164,6 +167,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
             If container Is Nothing Then
                 Return ImmutableArray(Of ISymbol).Empty
             End If
+
             Dim symbols = semanticModel.LookupSymbols(position, container)
 
             Dim hashSet = New HashSet(Of ISymbol)(symbols.ToArray() _
@@ -208,6 +212,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
                     defaultListing.Add(containingType.ContainingNamespace)
                     AddAliasesAndContainers(containingType.ContainingNamespace, defaultListing, node, semanticModel)
                 End If
+
                 Return defaultListing.ToImmutableArray()
             End If
 
diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.vb
index 5afcb1cb1455e..c090b7c6f9165 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.vb
@@ -230,6 +230,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
             Else
                 change = New TextChange(symbolItem.Span, insertionText)
             End If
+
             Return Task.FromResult(Of TextChange?)(change)
         End Function
     End Class
diff --git a/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/Declarations/EndBlockKeywordRecommender.vb b/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/Declarations/EndBlockKeywordRecommender.vb
index 28d0cefe6100a..d7a549d7e754d 100644
--- a/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/Declarations/EndBlockKeywordRecommender.vb
+++ b/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/Declarations/EndBlockKeywordRecommender.vb
@@ -88,6 +88,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.KeywordRecommenders.Decl
                             collection.Add(item2)
                         End If
                     Next
+
                     Exit For
                 End If
             Next
diff --git a/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/Declarations/GenericConstraintsKeywordRecommender.vb b/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/Declarations/GenericConstraintsKeywordRecommender.vb
index c840aa64b4921..c91fc6142b9aa 100644
--- a/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/Declarations/GenericConstraintsKeywordRecommender.vb
+++ b/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/Declarations/GenericConstraintsKeywordRecommender.vb
@@ -37,9 +37,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.KeywordRecommenders.Decl
                     If previousConstraints.Any(Function(constraint) Not constraint.IsKind(SyntaxKind.TypeConstraint)) Then
                         recommendations.RemoveAll(Function(k) k.Keyword = "Structure")
                     End If
+
                     If previousConstraints.Any(Function(constraint) constraint.IsKind(SyntaxKind.ClassConstraint, SyntaxKind.StructureConstraint)) Then
                         recommendations.RemoveAll(Function(k) k.Keyword = "Class")
                     End If
+
                     If previousConstraints.Any(Function(constraint) constraint.IsKind(SyntaxKind.NewConstraint, SyntaxKind.StructureConstraint)) Then
                         recommendations.RemoveAll(Function(k) k.Keyword = "New")
                     End If
diff --git a/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/PreprocessorDirectives/PreprocessorHelpers.vb b/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/PreprocessorDirectives/PreprocessorHelpers.vb
index 9d68f26049a40..4ebea42caca39 100644
--- a/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/PreprocessorDirectives/PreprocessorHelpers.vb
+++ b/src/Features/VisualBasic/Portable/Completion/KeywordRecommenders/PreprocessorDirectives/PreprocessorHelpers.vb
@@ -45,6 +45,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.KeywordRecommenders.Prep
                     If child.FullSpan.Start > _maxPosition Then
                         Exit For
                     End If
+
                     If child.IsNode Then
                         Visit(child.AsNode())
                     End If
diff --git a/src/Features/VisualBasic/Portable/EditAndContinue/SyntaxComparer.vb b/src/Features/VisualBasic/Portable/EditAndContinue/SyntaxComparer.vb
index 81081ccd2928b..8eaf50ee137bf 100644
--- a/src/Features/VisualBasic/Portable/EditAndContinue/SyntaxComparer.vb
+++ b/src/Features/VisualBasic/Portable/EditAndContinue/SyntaxComparer.vb
@@ -871,6 +871,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         isLeaf = False
                         Return Label.AttributeList
                     End If
+
                     isLeaf = True
                     Return Label.Ignored
 
@@ -879,6 +880,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                     If nodeOpt IsNot Nothing AndAlso nodeOpt.Parent.IsParentKind(SyntaxKind.AttributesStatement) Then
                         Return Label.Attribute
                     End If
+
                     Return Label.Ignored
 
                 Case Else
diff --git a/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb b/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb
index 0dcaaea8c095b..75eab22cc8d3b 100644
--- a/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb
+++ b/src/Features/VisualBasic/Portable/EditAndContinue/VisualBasicEditAndContinueAnalyzer.vb
@@ -1280,16 +1280,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         node = node.Parent             ' for attributes on return types of functions
                     End If
 
-                Case SyntaxKind.EventStatement
-                    If node.Parent.IsKind(SyntaxKind.EventBlock) Then
-                        Return False
-                    End If
-
-                Case SyntaxKind.PropertyStatement  ' autoprop or interface property
-                    If node.Parent.IsKind(SyntaxKind.PropertyBlock) Then
-                        Return False
-                    End If
-
                 Case SyntaxKind.Parameter
                     If editKind = EditKind.Update Then
                         ' for delegate invoke methods we need to go one step higher, to the delegate itself
@@ -1302,6 +1292,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         symbols = OneOrMany.Create(parameterSymbol)
                         Return True
                     End If
+
                     Return False
 
                 Case SyntaxKind.TypeParameter
@@ -1328,6 +1319,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         symbols = OneOrMany.Create(variableDeclarator.Names.SelectAsArray(Function(n) model.GetDeclaredSymbol(n, cancellationToken)))
                         Return True
                     End If
+
                     node = variableDeclarator.Names(0)
 
                 Case SyntaxKind.FieldDeclaration
@@ -2284,6 +2276,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         If node.Parent.IsParentKind(SyntaxKind.AttributesStatement) Then
                             ReportError(RudeEditKind.Insert)
                         End If
+
                         Return
 
                     Case SyntaxKind.AttributeList
@@ -2291,6 +2284,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         If node.IsParentKind(SyntaxKind.AttributesStatement) Then
                             ReportError(RudeEditKind.Insert)
                         End If
+
                         Return
 
                     Case SyntaxKind.ParameterList
@@ -2366,6 +2360,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         If oldNode.IsParentKind(SyntaxKind.AttributesStatement) Then
                             ReportError(RudeEditKind.Insert)
                         End If
+
                         Return
 
                     Case SyntaxKind.Attribute
@@ -2373,6 +2368,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         If oldNode.Parent.IsParentKind(SyntaxKind.AttributesStatement) Then
                             ReportError(RudeEditKind.Insert)
                         End If
+
                         Return
 
                     Case SyntaxKind.TypeParameter,
@@ -2456,7 +2452,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         Return
 
                     Case SyntaxKind.FieldDeclaration
-                        ClassifyUpdate(DirectCast(oldNode, FieldDeclarationSyntax), DirectCast(newNode, FieldDeclarationSyntax))
                         Return
 
                     Case SyntaxKind.VariableDeclarator
@@ -2499,7 +2494,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         Return
 
                     Case SyntaxKind.SubNewStatement
-                        ClassifyUpdate(DirectCast(oldNode, SubNewStatementSyntax), DirectCast(newNode, SubNewStatementSyntax))
                         Return
 
                     Case SyntaxKind.PropertyBlock
@@ -2568,6 +2562,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                         If newNode.Parent.IsParentKind(SyntaxKind.AttributesStatement) Then
                             ReportError(RudeEditKind.Update)
                         End If
+
                         Return
 
                     Case SyntaxKind.AttributeList,
@@ -2586,16 +2581,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
             End Sub
 
             Private Sub ClassifyUpdate(oldNode As TypeStatementSyntax, newNode As TypeStatementSyntax)
-                If oldNode.RawKind <> newNode.RawKind Then
-                    ReportError(RudeEditKind.TypeKindUpdate)
-                    Return
-                End If
-
-                If Not AreModifiersEquivalent(oldNode.Modifiers, newNode.Modifiers, ignore:=SyntaxKind.PartialKeyword) Then
-                    ReportError(RudeEditKind.ModifiersUpdate)
-                    Return
-                End If
-
                 If Not SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier) Then
                     ReportError(RudeEditKind.Renamed)
                 End If
@@ -2616,11 +2601,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                     Return
                 End If
 
-                If Not SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers) Then
-                    ReportError(RudeEditKind.ModifiersUpdate)
-                    Return
-                End If
-
                 If Not SyntaxFactory.AreEquivalent(oldNode.UnderlyingType, newNode.UnderlyingType) Then
                     ReportError(RudeEditKind.EnumUnderlyingTypeUpdate)
                     Return
@@ -2628,11 +2608,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
             End Sub
 
             Private Sub ClassifyUpdate(oldNode As DelegateStatementSyntax, newNode As DelegateStatementSyntax)
-                If Not SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers) Then
-                    ReportError(RudeEditKind.ModifiersUpdate)
-                    Return
-                End If
-
                 ' Function changed to Sub or vice versa. Note that Function doesn't need to have AsClause.
                 If oldNode.RawKind <> newNode.RawKind Then
                     ReportError(RudeEditKind.TypeUpdate)
@@ -2650,14 +2625,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                 End If
             End Sub
 
-            Private Sub ClassifyUpdate(oldNode As FieldDeclarationSyntax, newNode As FieldDeclarationSyntax)
-                If Not SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers) Then
-                    ReportError(RudeEditKind.ModifiersUpdate)
-                End If
-
-                ' VariableDeclarator separators were modified
-            End Sub
-
             Private Sub ClassifyUpdate(oldNode As ModifiedIdentifierSyntax, newNode As ModifiedIdentifierSyntax)
                 If Not SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier) Then
                     ReportError(RudeEditKind.Renamed)
@@ -2709,12 +2676,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
             End Sub
 
             Private Sub ClassifyUpdate(oldNode As PropertyStatementSyntax, newNode As PropertyStatementSyntax)
-                If Not IncludesSignificantPropertyModifiers(oldNode.Modifiers, newNode.Modifiers) OrElse
-                   Not IncludesSignificantPropertyModifiers(newNode.Modifiers, oldNode.Modifiers) Then
-                    ReportError(RudeEditKind.ModifiersUpdate)
-                    Return
-                End If
-
                 If Not SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier) Then
                     ReportError(RudeEditKind.Renamed)
                     Return
@@ -2735,23 +2696,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                 End If
             End Sub
 
-            Private Shared Function IncludesSignificantPropertyModifiers(subset As SyntaxTokenList, superset As SyntaxTokenList) As Boolean
-                For Each modifier In subset
-                    ' ReadOnly and WriteOnly keywords are redundant, it would be a semantic error if they Then didn't match the present accessors. 
-                    ' We want to allow adding an accessor to a property, which requires change in the RO/WO modifiers.
-                    If modifier.IsKind(SyntaxKind.ReadOnlyKeyword) OrElse
-                       modifier.IsKind(SyntaxKind.WriteOnlyKeyword) Then
-                        Continue For
-                    End If
-
-                    If Not superset.Any(modifier.Kind) Then
-                        Return False
-                    End If
-                Next
-
-                Return True
-            End Function
-
             ' Returns true if the initializer has changed.
             Private Function ClassifyTypeAndInitializerUpdates(oldEqualsValue As EqualsValueSyntax,
                                                                oldClause As AsClauseSyntax,
@@ -2773,10 +2717,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                 ' A custom event can't be matched with a field event and vice versa:
                 Debug.Assert(SyntaxFactory.AreEquivalent(oldNode.CustomKeyword, newNode.CustomKeyword))
 
-                If Not SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers) Then
-                    ReportError(RudeEditKind.ModifiersUpdate)
-                End If
-
                 If Not SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier) Then
                     ReportError(RudeEditKind.Renamed)
                     Return
@@ -2790,8 +2730,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                 Dim oldHasGeneratedType = oldNode.ParameterList IsNot Nothing
                 Dim newHasGeneratedType = newNode.ParameterList IsNot Nothing
 
-                Debug.Assert(oldHasGeneratedType <> newHasGeneratedType)
-                ReportError(RudeEditKind.TypeUpdate)
+                If oldHasGeneratedType <> newHasGeneratedType Then
+                    ReportError(RudeEditKind.TypeUpdate)
+                End If
             End Sub
 
             Private Sub ClassifyUpdate(oldNode As MethodBlockSyntax, newNode As MethodBlockSyntax)
@@ -2812,11 +2753,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                     Return
                 End If
 
-                If Not ClassifyMethodModifierUpdate(oldNode.Modifiers, newNode.Modifiers) Then
-                    ReportError(RudeEditKind.ModifiersUpdate)
-                    Return
-                End If
-
                 ' TODO (tomat): We can support this
                 If Not SyntaxFactory.AreEquivalent(oldNode.HandlesClause, newNode.HandlesClause) Then
                     ReportError(RudeEditKind.HandlesClauseUpdate)
@@ -2829,35 +2765,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                 End If
             End Sub
 
-            Private Shared Function ClassifyMethodModifierUpdate(oldModifiers As SyntaxTokenList, newModifiers As SyntaxTokenList) As Boolean
-                ' Ignore Async and Iterator keywords when matching modifiers.
-                ' State machine checks are done in ComputeBodyMatch.
-
-                Dim oldAsyncIndex = oldModifiers.IndexOf(SyntaxKind.AsyncKeyword)
-                Dim newAsyncIndex = newModifiers.IndexOf(SyntaxKind.AsyncKeyword)
-
-                If oldAsyncIndex >= 0 Then
-                    oldModifiers = oldModifiers.RemoveAt(oldAsyncIndex)
-                End If
-
-                If newAsyncIndex >= 0 Then
-                    newModifiers = newModifiers.RemoveAt(newAsyncIndex)
-                End If
-
-                Dim oldIteratorIndex = oldModifiers.IndexOf(SyntaxKind.IteratorKeyword)
-                Dim newIteratorIndex = newModifiers.IndexOf(SyntaxKind.IteratorKeyword)
-
-                If oldIteratorIndex >= 0 Then
-                    oldModifiers = oldModifiers.RemoveAt(oldIteratorIndex)
-                End If
-
-                If newIteratorIndex >= 0 Then
-                    newModifiers = newModifiers.RemoveAt(newIteratorIndex)
-                End If
-
-                Return SyntaxFactory.AreEquivalent(oldModifiers, newModifiers)
-            End Function
-
             Private Sub ClassifyUpdate(oldNode As DeclareStatementSyntax, newNode As DeclareStatementSyntax)
                 If Not SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier) Then
                     ReportError(RudeEditKind.Renamed)
@@ -2891,13 +2798,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
             End Sub
 
             Private Sub ClassifyUpdate(oldNode As OperatorStatementSyntax, newNode As OperatorStatementSyntax)
-                If Not SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers) Then
+                Dim oldWidening = oldNode.Modifiers.IndexOf(SyntaxKind.WideningKeyword) >= 0
+                Dim oldNarrowing = oldNode.Modifiers.IndexOf(SyntaxKind.NarrowingKeyword) >= 0
+                Dim newWidening = newNode.Modifiers.IndexOf(SyntaxKind.WideningKeyword) >= 0
+                Dim newNarrowing = newNode.Modifiers.IndexOf(SyntaxKind.NarrowingKeyword) >= 0
+
+                If newWidening <> oldWidening OrElse newNarrowing <> oldNarrowing Then
                     ReportError(RudeEditKind.ModifiersUpdate)
                     Return
                 End If
-
-                Debug.Assert(Not SyntaxFactory.AreEquivalent(oldNode.OperatorToken, newNode.OperatorToken))
-                ReportError(RudeEditKind.Renamed)
             End Sub
 
             Private Sub ClassifyUpdate(oldNode As AccessorBlockSyntax, newNode As AccessorBlockSyntax)
@@ -2929,13 +2838,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                                              containingType:=DirectCast(newNode.Parent, TypeBlockSyntax))
             End Sub
 
-            Private Sub ClassifyUpdate(oldNode As SubNewStatementSyntax, newNode As SubNewStatementSyntax)
-                If Not SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers) Then
-                    ReportError(RudeEditKind.ModifiersUpdate)
-                    Return
-                End If
-            End Sub
-
             Private Sub ClassifyUpdate(oldNode As SimpleAsClauseSyntax, newNode As SimpleAsClauseSyntax)
                 If Not SyntaxFactory.AreEquivalent(oldNode.Type, newNode.Type) Then
                     ReportError(RudeEditKind.TypeUpdate, newNode.Parent, newNode.Parent)
@@ -2977,21 +2879,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.EditAndContinue
                 ClassifyUpdate(oldNode.Identifier, newNode.Identifier)
             End Sub
 
-            Private Shared Function AreModifiersEquivalent(oldModifiers As SyntaxTokenList, newModifiers As SyntaxTokenList, ignore As SyntaxKind) As Boolean
-                Dim oldIgnoredModifierIndex = oldModifiers.IndexOf(ignore)
-                Dim newIgnoredModifierIndex = newModifiers.IndexOf(ignore)
-
-                If oldIgnoredModifierIndex >= 0 Then
-                    oldModifiers = oldModifiers.RemoveAt(oldIgnoredModifierIndex)
-                End If
-
-                If newIgnoredModifierIndex >= 0 Then
-                    newModifiers = newModifiers.RemoveAt(newIgnoredModifierIndex)
-                End If
-
-                Return SyntaxFactory.AreEquivalent(oldModifiers, newModifiers)
-            End Function
-
             Private Sub ClassifyMethodBodyRudeUpdate(oldBody As MethodBlockBaseSyntax,
                                                      newBody As MethodBlockBaseSyntax,
                                                      containingMethod As MethodBlockSyntax,
diff --git a/src/Features/VisualBasic/Portable/ExtractMethod/Extensions.vb b/src/Features/VisualBasic/Portable/ExtractMethod/Extensions.vb
index 5bacc240252ff..bfbbec93ed1b4 100644
--- a/src/Features/VisualBasic/Portable/ExtractMethod/Extensions.vb
+++ b/src/Features/VisualBasic/Portable/ExtractMethod/Extensions.vb
@@ -360,6 +360,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExtractMethod
                 If tuple.Item2.Kind = SyntaxKind.None Then
                     Exit For
                 End If
+
                 list.Add(tuple.Item2)
             Next
 
diff --git a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicMethodExtractor.VisualBasicCodeGenerator.vb b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicMethodExtractor.VisualBasicCodeGenerator.vb
index 7a92589b69c61..92102b94dc4a9 100644
--- a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicMethodExtractor.VisualBasicCodeGenerator.vb
+++ b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicMethodExtractor.VisualBasicCodeGenerator.vb
@@ -363,6 +363,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExtractMethod
                                         SyntaxFactory.Token(SyntaxKind.FalseKeyword))))))
                         End If
                     End If
+
                     Return SyntaxFactory.AwaitExpression(invocation)
                 End If
 
diff --git a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionValidator.vb b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionValidator.vb
index 9f271f38908ef..dedff2bc9d048 100644
--- a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionValidator.vb
+++ b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionValidator.vb
@@ -201,6 +201,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExtractMethod
                 If range Is Nothing Then
                     Return True
                 End If
+
                 result = semanticModel.AnalyzeDataFlow(range.Item1, range.Item2)
             End If
 
@@ -253,6 +254,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                 .FirstTokenInFinalSpan = firstToken
                 .LastTokenInFinalSpan = lastToken
             End With
+
             Return clone
         End Function
 
@@ -284,6 +286,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                 With clone
                     .Status = .Status.With(OperationStatusFlag.None, VBFeaturesResources.next_statement_control_variable_doesn_t_have_matching_declaration_statement)
                 End With
+
                 Return clone
             End If
 
@@ -294,6 +297,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                 With clone
                     .Status = .Status.With(OperationStatusFlag.None, VBFeaturesResources.next_statement_control_variable_doesn_t_have_matching_declaration_statement)
                 End With
+
                 Return clone
             End If
 
@@ -304,6 +308,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                 .FirstTokenInFinalSpan = firstStatement.GetFirstToken(includeZeroWidth:=True)
                 .LastTokenInFinalSpan = nextStatement.GetLastToken(includeZeroWidth:=True)
             End With
+
             Return clone
         End Function
 
@@ -339,6 +344,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                     .FirstTokenInFinalSpan = Nothing
                     .LastTokenInFinalSpan = Nothing
                 End With
+
                 Return clone
             End If
 
@@ -348,6 +354,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                 .FirstTokenInFinalSpan = firstValidNode.GetFirstToken(includeZeroWidth:=True)
                 .LastTokenInFinalSpan = firstValidNode.GetLastToken(includeZeroWidth:=True)
             End With
+
             Return clone
         End Function
 
@@ -369,6 +376,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                     .FirstTokenInFinalSpan = outerNode.GetFirstToken(includeZeroWidth:=True)
                     .LastTokenInFinalSpan = outerNode.GetLastToken(includeZeroWidth:=True)
                 End With
+
                 Return clone
             End If
 
@@ -380,6 +388,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                 With clone
                     .Status = clone.Status.With(OperationStatusFlag.None, VBFeaturesResources.no_valid_statement_range_to_extract_out)
                 End With
+
                 Return clone
             End If
 
@@ -395,6 +404,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                         .FirstTokenInFinalSpan = expression.GetFirstToken(includeZeroWidth:=True)
                         .LastTokenInFinalSpan = expression.GetLastToken(includeZeroWidth:=True)
                     End With
+
                     Return clone
                 End If
 
@@ -407,6 +417,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                     With clone
                         .Status = clone.Status.With(OperationStatusFlag.None, VBFeaturesResources.no_valid_statement_range_to_extract_out)
                     End With
+
                     Return clone
                 End If
 
@@ -415,6 +426,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                     .FirstTokenInFinalSpan = singleStatement.GetFirstToken(includeZeroWidth:=True)
                     .LastTokenInFinalSpan = singleStatement.GetLastToken(includeZeroWidth:=True)
                 End With
+
                 Return clone
             End If
 
@@ -438,6 +450,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                         .FirstTokenInFinalSpan = parent.GetFirstToken()
                         .LastTokenInFinalSpan = parent.GetLastToken()
                     End With
+
                     Return clone
                 End If
             End If
@@ -446,6 +459,7 @@ result.ReadOutside().Any(Function(s) Equals(s, local)) Then
                 .FirstTokenInFinalSpan = statement1.GetFirstToken(includeZeroWidth:=True)
                 .LastTokenInFinalSpan = statement2.GetLastToken(includeZeroWidth:=True)
             End With
+
             Return clone
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/FullyQualify/VisualBasicFullyQualifyCodeFixProvider.vb b/src/Features/VisualBasic/Portable/FullyQualify/VisualBasicFullyQualifyCodeFixProvider.vb
index 20872e43ef416..5d3b2831c7dfd 100644
--- a/src/Features/VisualBasic/Portable/FullyQualify/VisualBasicFullyQualifyCodeFixProvider.vb
+++ b/src/Features/VisualBasic/Portable/FullyQualify/VisualBasicFullyQualifyCodeFixProvider.vb
@@ -91,8 +91,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.FullyQualify
                 If simpleName IsNot Nothing Then
                     Return simpleName
                 End If
+
                 qn = TryCast(left, QualifiedNameSyntax)
             End While
+
             Return Nothing
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb b/src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb
index 7796e3e8b1f20..0aef8dafbcb20 100644
--- a/src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb
+++ b/src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb
@@ -176,12 +176,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateConstructor
             If (constructorStatements.IsEmpty()) Then
                 Return Nothing
             End If
+
             Dim constructorInitializerSyntax = constructorStatements(0)
             Dim expressionStatement = TryCast(constructorInitializerSyntax, ExpressionStatementSyntax)
             If (expressionStatement IsNot Nothing AndAlso expressionStatement.Expression.IsKind(SyntaxKind.InvocationExpression)) Then
                 Dim methodSymbol = TryCast(semanticModel.GetSymbolInfo(expressionStatement.Expression, cancellationToken).Symbol, IMethodSymbol)
                 Return If(methodSymbol IsNot Nothing AndAlso methodSymbol.MethodKind = MethodKind.Constructor, methodSymbol, Nothing)
             End If
+
             Return Nothing
         End Function
     End Class
diff --git a/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb b/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb
index 1622ceb144d00..c11b85604a33b 100644
--- a/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb
+++ b/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb
@@ -122,6 +122,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateMethod
             If Not ValidateTypeToGenerateIn(typeToGenerateIn, True, classInterfaceModuleStructTypes) Then
                 typeToGenerateIn = parameterSymbol
             End If
+
             Return True
         End Function
 
@@ -137,6 +138,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateMethod
             If Not ValidateTypeToGenerateIn(typeToGenerateIn, True, classInterfaceModuleStructTypes) Then
                 typeToGenerateIn = parameterSymbol
             End If
+
             Return True
         End Function
 
@@ -144,6 +146,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateMethod
             If typeToGenerateIn.IsGenericType Then
                 typeToGenerateIn = typeToGenerateIn.ConstructUnboundGenericType.ConstructedFrom
             End If
+
             Return CodeGenerationSymbolFactory.CreateMethodSymbol(
                 attributes:=ImmutableArray(Of AttributeData).Empty,
                 accessibility:=Nothing,
diff --git a/src/Features/VisualBasic/Portable/GenerateType/VisualBasicGenerateTypeService.vb b/src/Features/VisualBasic/Portable/GenerateType/VisualBasicGenerateTypeService.vb
index a803ca6f207f6..df35bfcb8462b 100644
--- a/src/Features/VisualBasic/Portable/GenerateType/VisualBasicGenerateTypeService.vb
+++ b/src/Features/VisualBasic/Portable/GenerateType/VisualBasicGenerateTypeService.vb
@@ -686,6 +686,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateType
             If fieldInitializer IsNot Nothing Then
                 Return typeInference.InferType(semanticModel, fieldInitializer.Name, True, cancellationToken)
             End If
+
             Return Nothing
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/InvertIf/VisualBasicInvertIfCodeRefactoringProvider.MultiLine.vb b/src/Features/VisualBasic/Portable/InvertIf/VisualBasicInvertIfCodeRefactoringProvider.MultiLine.vb
index faac8f5e1eb83..00a9e55be5864 100644
--- a/src/Features/VisualBasic/Portable/InvertIf/VisualBasicInvertIfCodeRefactoringProvider.MultiLine.vb
+++ b/src/Features/VisualBasic/Portable/InvertIf/VisualBasicInvertIfCodeRefactoringProvider.MultiLine.vb
@@ -51,10 +51,24 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.InvertIf
 
             If falseStatementOpt.Count > 0 Then
                 updatedIf = updatedIf.WithElseBlock(SyntaxFactory.ElseBlock(falseStatementOpt))
+            ElseIf HasComment(ifNode.ElseBlock) Then
+                ' If the original else block has leading trivia
+                ' then we need to mantain that trivia for the new statement.
+                ' This should be attached to the "EndIf" statement now
+                ' because that will make it show up in the else block
+                Dim newEndIfStatement = SyntaxFactory.EndIfStatement().WithLeadingTrivia(ifNode.ElseBlock.GetLeadingTrivia())
+                updatedIf = updatedIf.WithEndIfStatement(newEndIfStatement)
+                updatedIf = updatedIf.WithElseBlock(SyntaxFactory.ElseBlock())
+            Else
+                updatedIf = updatedIf.WithElseBlock(Nothing)
             End If
 
             Return updatedIf
         End Function
+
+        Private Shared Function HasComment(elseBlock As ElseBlockSyntax) As Boolean
+            Return elseBlock.GetLeadingTrivia().Any(Function(trivia) trivia.IsKind(SyntaxKind.CommentTrivia))
+        End Function
     End Class
 End Namespace
 
diff --git a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicAnonymousTypeDisplayService.vb b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicAnonymousTypeDisplayService.vb
index 6f8c8515459e5..84a3e998cbcb9 100644
--- a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicAnonymousTypeDisplayService.vb
+++ b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicAnonymousTypeDisplayService.vb
@@ -97,6 +97,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
                 If Not first Then
                     members.Add(Punctuation(SyntaxFacts.GetText(SyntaxKind.CommaToken)))
                 End If
+
                 first = False
 
                 If [property].IsReadOnly Then
diff --git a/src/Features/VisualBasic/Portable/RemoveSharedFromModuleMembers/VisualBasicRemoveSharedFromModuleMembersCodeFixProvider.vb b/src/Features/VisualBasic/Portable/RemoveSharedFromModuleMembers/VisualBasicRemoveSharedFromModuleMembersCodeFixProvider.vb
index 48904e69fba69..37cf39950bde1 100644
--- a/src/Features/VisualBasic/Portable/RemoveSharedFromModuleMembers/VisualBasicRemoveSharedFromModuleMembersCodeFixProvider.vb
+++ b/src/Features/VisualBasic/Portable/RemoveSharedFromModuleMembers/VisualBasicRemoveSharedFromModuleMembersCodeFixProvider.vb
@@ -64,6 +64,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.RemoveSharedFromModuleMembers
                 Dim newNode = GetReplacement(document, node)
                 editor.ReplaceNode(node, newNode)
             Next
+
             Return Task.CompletedTask
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/SignatureHelp/GenericNameSignatureHelpProvider.vb b/src/Features/VisualBasic/Portable/SignatureHelp/GenericNameSignatureHelpProvider.vb
index f68918a5d06cc..a25125469b11f 100644
--- a/src/Features/VisualBasic/Portable/SignatureHelp/GenericNameSignatureHelpProvider.vb
+++ b/src/Features/VisualBasic/Portable/SignatureHelp/GenericNameSignatureHelpProvider.vb
@@ -198,6 +198,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.SignatureHelp
                         parts.Add(Punctuation(SyntaxKind.CommaToken))
                         parts.Add(Space())
                     End If
+
                     parts.Add(Keyword(SyntaxKind.NewKeyword))
                 End If
 
diff --git a/src/Features/VisualBasic/Portable/SpellCheck/VisualBasicSpellCheckCodeFixProvider.vb b/src/Features/VisualBasic/Portable/SpellCheck/VisualBasicSpellCheckCodeFixProvider.vb
index 580082e865f5c..5dbd1d98bac50 100644
--- a/src/Features/VisualBasic/Portable/SpellCheck/VisualBasicSpellCheckCodeFixProvider.vb
+++ b/src/Features/VisualBasic/Portable/SpellCheck/VisualBasicSpellCheckCodeFixProvider.vb
@@ -76,6 +76,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.SpellCheck
             If nameToken.IsBracketed() AndAlso Not newName.StartsWith("[") Then
                 newName = "[" + newName + "]"
             End If
+
             Return SyntaxFactory.Identifier(newName).WithTriviaFrom(nameToken)
         End Function
     End Class
diff --git a/src/Setup/DevDivInsertionFiles/DevDivInsertionFiles.csproj b/src/Setup/DevDivInsertionFiles/DevDivInsertionFiles.csproj
index 82bb66a741dc3..8988a5b254517 100644
--- a/src/Setup/DevDivInsertionFiles/DevDivInsertionFiles.csproj
+++ b/src/Setup/DevDivInsertionFiles/DevDivInsertionFiles.csproj
@@ -258,6 +258,7 @@
     <PropertyGroup>
       <_OptimizedNuGetPackageVersionSuffix Condition="'$(OfficialBuild)' != 'true'">vs-ci</_OptimizedNuGetPackageVersionSuffix>
       <_OptimizedNuGetPackageVersionSuffix Condition="'$(OfficialBuild)' == 'true'">vs-$(VersionSuffixDateStamp)-$(VersionSuffixBuildOfTheDayPadded)</_OptimizedNuGetPackageVersionSuffix>
+      <_OptimizedNuGetPackageVersionSuffix Condition="'$(PreReleaseVersionLabel)' == 'pr-validation'">pr-validation-$(VersionSuffixDateStamp)-$(VersionSuffixBuildOfTheDayPadded)</_OptimizedNuGetPackageVersionSuffix>
     </PropertyGroup>
 
     <MakeDir Directories="$(VisualStudioBuildPackagesDir)"/>
diff --git a/src/Tools/IdeBenchmarks/SQLitePersistentStorageBenchmark.cs b/src/Tools/IdeBenchmarks/SQLitePersistentStorageBenchmark.cs
index 6eba6f1291013..9dc2949a346a5 100644
--- a/src/Tools/IdeBenchmarks/SQLitePersistentStorageBenchmark.cs
+++ b/src/Tools/IdeBenchmarks/SQLitePersistentStorageBenchmark.cs
@@ -14,6 +14,7 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PersistentStorage;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SQLite.v2;
 using Microsoft.CodeAnalysis.Storage;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -68,7 +69,9 @@ public void GlobalSetup()
                 .WithChangedOption(StorageOptions.DatabaseMustSucceed, true)));
 
             var connectionPoolService = _workspace.ExportProvider.GetExportedValue<SQLiteConnectionPoolService>();
-            _storageService = new SQLitePersistentStorageService(_workspace.Options, connectionPoolService, new LocationService());
+            _storageService = new SQLitePersistentStorageService(
+                _workspace.Options, connectionPoolService, new LocationService(),
+                _workspace.ExportProvider.GetExportedValue<IAsynchronousOperationListenerProvider>().GetListener(FeatureAttribute.PersistentStorage));
 
             var solution = _workspace.CurrentSolution;
             _storage = _storageService.GetStorageWorkerAsync(_workspace, SolutionKey.ToSolutionKey(solution), solution, CancellationToken.None).AsTask().GetAwaiter().GetResult();
diff --git a/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx b/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx
index 0f4ab0b7f04fc..9199149dd86ac 100644
--- a/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx
+++ b/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx
@@ -640,4 +640,7 @@
   <data name="Automatically_complete_statement_on_semicolon" xml:space="preserve">
     <value>Automatically complete statement on semicolon</value>
   </data>
+  <data name="Prefer_null_check_over_type_check" xml:space="preserve">
+    <value>Prefer 'null' check over type check</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/VisualStudio/CSharp/Impl/CodeModel/CSharpCodeModelService.cs b/src/VisualStudio/CSharp/Impl/CodeModel/CSharpCodeModelService.cs
index b971a269abbb5..30b7dd781d14a 100644
--- a/src/VisualStudio/CSharp/Impl/CodeModel/CSharpCodeModelService.cs
+++ b/src/VisualStudio/CSharp/Impl/CodeModel/CSharpCodeModelService.cs
@@ -438,6 +438,12 @@ private static bool NodeIsSupported(bool test, SyntaxNode node)
         /// of the field.</param>
         /// <param name="onlySupportedNodes">If true, only members supported by Code Model are returned.</param>
         public override IEnumerable<SyntaxNode> GetMemberNodes(SyntaxNode container, bool includeSelf, bool recursive, bool logicalFields, bool onlySupportedNodes)
+        {
+            // Filter out all records from code model, they are not supported at all.
+            return GetMemberNodesWorker(container, includeSelf, recursive, logicalFields, onlySupportedNodes).Where(t => t is not RecordDeclarationSyntax);
+        }
+
+        private IEnumerable<SyntaxNode> GetMemberNodesWorker(SyntaxNode container, bool includeSelf, bool recursive, bool logicalFields, bool onlySupportedNodes)
         {
             if (!IsContainerNode(container))
             {
diff --git a/src/VisualStudio/CSharp/Impl/LanguageService/CSharpCodeCleanupFixerProvider.cs b/src/VisualStudio/CSharp/Impl/LanguageService/CSharpCodeCleanupFixerProvider.cs
index 93823b5ae6970..45b98a5af483a 100644
--- a/src/VisualStudio/CSharp/Impl/LanguageService/CSharpCodeCleanupFixerProvider.cs
+++ b/src/VisualStudio/CSharp/Impl/LanguageService/CSharpCodeCleanupFixerProvider.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
@@ -26,4 +26,4 @@ public CSharpCodeCleanUpFixerProvider(
         {
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
index eb94fe1fa39dc..da1a53ea12d4c 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
@@ -33,7 +33,9 @@
                     <CheckBox x:Name="Enable_pull_diagnostics_experimental_requires_restart"
                               Content="{x:Static local:AdvancedOptionPageStrings.Option_Enable_pull_diagnostics_experimental_requires_restart}" 
                               Checked="Enable_pull_diagnostics_experimental_requires_restart_Checked"
-                              Unchecked="Enable_pull_diagnostics_experimental_requires_restart_Unchecked"/>
+                              Unchecked="Enable_pull_diagnostics_experimental_requires_restart_Unchecked"
+                              Indeterminate="Enable_pull_diagnostics_experimental_requires_restart_Indeterminate"
+                              IsThreeState="True"/>
 
                     <CheckBox x:Name="Enable_Razor_pull_diagnostics_experimental_requires_restart"
                               Content="{x:Static local:AdvancedOptionPageStrings.Option_Enable_Razor_pull_diagnostics_experimental_requires_restart}" 
@@ -48,6 +50,9 @@
 
                     <CheckBox x:Name="Enable_file_logging_for_diagnostics"
                               Content="{x:Static local:AdvancedOptionPageStrings.Option_Enable_file_logging_for_diagnostics}" />
+
+                    <CheckBox x:Name="Skip_analyzers_for_implicitly_triggered_builds"
+                              Content="{x:Static local:AdvancedOptionPageStrings.Option_Skip_analyzers_for_implicitly_triggered_builds}" />
                 </StackPanel>
             </GroupBox>
             <GroupBox x:Uid="UsingDirectivesGroupBox"
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
index 8d6f37ebbdc88..358cdfcac9d51 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
@@ -48,6 +48,7 @@ public AdvancedOptionPageControl(OptionStore optionStore, IComponentModel compon
             BindToOption(Enable_navigation_to_decompiled_sources, FeatureOnOffOptions.NavigateToDecompiledSources);
             BindToOption(Use_64bit_analysis_process, RemoteHostOptions.OOP64Bit);
             BindToOption(Enable_file_logging_for_diagnostics, InternalDiagnosticsOptions.EnableFileLoggingForDiagnostics);
+            BindToOption(Skip_analyzers_for_implicitly_triggered_builds, FeatureOnOffOptions.SkipAnalyzersForImplicitlyTriggeredBuilds);
             BindToOption(Show_Remove_Unused_References_command_in_Solution_Explorer_experimental, FeatureOnOffOptions.OfferRemoveUnusedReferences, () =>
             {
                 // If the option has not been set by the user, check if the option to remove unused references
@@ -129,7 +130,10 @@ public AdvancedOptionPageControl(OptionStore optionStore, IComponentModel compon
             BindToOption(ShowHintsForLambdaParameterTypes, InlineHintsOptions.ForLambdaParameterTypes, LanguageNames.CSharp);
             BindToOption(ShowHintsForImplicitObjectCreation, InlineHintsOptions.ForImplicitObjectCreation, LanguageNames.CSharp);
 
-            BindToOption(ShowInheritanceMargin, FeatureOnOffOptions.ShowInheritanceMargin, LanguageNames.CSharp);
+            // If the option has not been set by the user, check if the option is enabled from experimentation.
+            // If so, default to that. Otherwise default to disabled
+            BindToOption(ShowInheritanceMargin, FeatureOnOffOptions.ShowInheritanceMargin, LanguageNames.CSharp, () =>
+                experimentationService?.IsExperimentEnabled(WellKnownExperimentNames.InheritanceMargin) ?? false);
         }
 
         // Since this dialog is constructed once for the lifetime of the application and VS Theme can be changed after the application has started,
@@ -151,8 +155,21 @@ internal override void OnLoad()
 
         private void UpdatePullDiagnosticsOptions()
         {
-            Enable_pull_diagnostics_experimental_requires_restart.IsChecked = OptionStore.GetOption(InternalDiagnosticsOptions.NormalDiagnosticMode) == DiagnosticMode.Pull;
+            var normalPullDiagnosticsOption = OptionStore.GetOption(InternalDiagnosticsOptions.NormalDiagnosticMode);
+            Enable_pull_diagnostics_experimental_requires_restart.IsChecked = GetDiagnosticModeCheckboxValue(normalPullDiagnosticsOption);
+
             Enable_Razor_pull_diagnostics_experimental_requires_restart.IsChecked = OptionStore.GetOption(InternalDiagnosticsOptions.RazorDiagnosticMode) == DiagnosticMode.Pull;
+
+            static bool? GetDiagnosticModeCheckboxValue(DiagnosticMode mode)
+            {
+                return mode switch
+                {
+                    DiagnosticMode.Push => false,
+                    DiagnosticMode.Pull => true,
+                    DiagnosticMode.Default => null,
+                    _ => throw new System.ArgumentException("unknown diagnostic mode"),
+                };
+            }
         }
 
         private void Enable_pull_diagnostics_experimental_requires_restart_Checked(object sender, RoutedEventArgs e)
@@ -167,6 +184,12 @@ private void Enable_pull_diagnostics_experimental_requires_restart_Unchecked(obj
             UpdatePullDiagnosticsOptions();
         }
 
+        private void Enable_pull_diagnostics_experimental_requires_restart_Indeterminate(object sender, RoutedEventArgs e)
+        {
+            this.OptionStore.SetOption(InternalDiagnosticsOptions.NormalDiagnosticMode, DiagnosticMode.Default);
+            UpdatePullDiagnosticsOptions();
+        }
+
         private void Enable_Razor_pull_diagnostics_experimental_requires_restart_Checked(object sender, RoutedEventArgs e)
         {
             this.OptionStore.SetOption(InternalDiagnosticsOptions.RazorDiagnosticMode, DiagnosticMode.Pull);
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
index 8454fcf481045..9ddfff6204ba3 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
@@ -273,6 +273,9 @@ public static string Enable_all_features_in_opened_files_from_source_generators_
         public static string Option_Enable_file_logging_for_diagnostics
             => ServicesVSResources.Enable_file_logging_for_diagnostics;
 
+        public static string Option_Skip_analyzers_for_implicitly_triggered_builds
+            => ServicesVSResources.Skip_analyzers_for_implicitly_triggered_builds;
+
         public static string Show_inheritance_margin
             => ServicesVSResources.Show_inheritance_margin;
 
diff --git a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.OnOff.cs b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.OnOff.cs
index efa1016d1bb16..e05ccaa61e125 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.OnOff.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.OnOff.cs
@@ -85,5 +85,11 @@ public int AutomaticallyCompleteStatementOnSemicolon
             get { return GetBooleanOption(FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon); }
             set { SetBooleanOption(FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon, value); }
         }
+
+        public int SkipAnalyzersForImplicitlyTriggeredBuilds
+        {
+            get { return GetBooleanOption(FeatureOnOffOptions.SkipAnalyzersForImplicitlyTriggeredBuilds); }
+            set { SetBooleanOption(FeatureOnOffOptions.SkipAnalyzersForImplicitlyTriggeredBuilds, value); }
+        }
     }
 }
diff --git a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs
index cb3fd043aa11c..def7d40b58687 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs
@@ -237,6 +237,12 @@ public string Style_PreferIsNullCheckOverReferenceEqualityMethod
             set { SetXmlOption(CodeStyleOptions2.PreferIsNullCheckOverReferenceEqualityMethod, value); }
         }
 
+        public string Style_PreferNullCheckOverTypeCheck
+        {
+            get { return GetXmlOption(CSharpCodeStyleOptions.PreferNullCheckOverTypeCheck); }
+            set { SetXmlOption(CSharpCodeStyleOptions.PreferNullCheckOverTypeCheck, value); }
+        }
+
         public string Style_PreferConditionalExpressionOverAssignment
         {
             get { return GetXmlOption(CodeStyleOptions2.PreferConditionalExpressionOverAssignment); }
diff --git a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
index 0ff0e414add14..41467fe1ed25d 100644
--- a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
@@ -1058,6 +1058,36 @@ void M2(string value1, string value2)
 //]
     }}
 }}
+";
+
+        private static readonly string s_preferNullcheckOverTypeCheck = $@"
+using System;
+
+class Customer
+{{
+    void M1(string value1, string value2)
+    {{
+//[
+        // {ServicesVSResources.Prefer_colon}
+        if (value1 is null)
+            return;
+
+        if (value2 is not null)
+            return;
+//]
+    }}
+    void M2(string value1, string value2)
+    {{
+//[
+        // {ServicesVSResources.Over_colon}
+        if (value1 is not object)
+            return;
+
+        if (value2 is object)
+            return;
+//]
+    }}
+}}
 ";
 
         #region expression and block bodies
@@ -2011,6 +2041,7 @@ internal StyleViewModel(OptionStore optionStore, IServiceProvider serviceProvide
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions2.PreferCoalesceExpression, ServicesVSResources.Prefer_coalesce_expression, s_preferCoalesceExpression, s_preferCoalesceExpression, this, optionStore, nullCheckingGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions2.PreferNullPropagation, ServicesVSResources.Prefer_null_propagation, s_preferNullPropagation, s_preferNullPropagation, this, optionStore, nullCheckingGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions2.PreferIsNullCheckOverReferenceEqualityMethod, CSharpVSResources.Prefer_is_null_for_reference_equality_checks, s_preferIsNullOverReferenceEquals, s_preferIsNullOverReferenceEquals, this, optionStore, nullCheckingGroupTitle));
+            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferNullCheckOverTypeCheck, CSharpVSResources.Prefer_null_check_over_type_check, s_preferNullcheckOverTypeCheck, s_preferNullcheckOverTypeCheck, this, optionStore, nullCheckingGroupTitle));
 
             // Using directive preferences.
             CodeStyleItems.Add(new EnumCodeStyleOptionViewModel<AddImportPlacement>(
diff --git a/src/VisualStudio/CSharp/Impl/VSPackage.resx b/src/VisualStudio/CSharp/Impl/VSPackage.resx
index 2177228dbf5fb..dd11388e0fa0c 100644
--- a/src/VisualStudio/CSharp/Impl/VSPackage.resx
+++ b/src/VisualStudio/CSharp/Impl/VSPackage.resx
@@ -190,7 +190,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</value>
+Editor Color Scheme;
+Inheritance Margin;</value>
     <comment>C# Advanced options page keywords</comment>
   </data>
   <data name="307" xml:space="preserve">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
index 0040a6a73293d..d6c965cc620ff 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
@@ -122,6 +122,11 @@
         <target state="translated">U kontrol rovnosti odkazů dávat přednost možnosti is null</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Upřednostňovat porovnávání vzorů</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
index 09219c0444092..c9444c135d8eb 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
@@ -122,6 +122,11 @@
         <target state="translated">"is null" für Verweisübereinstimmungsprüfungen vorziehen</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Musterabgleich bevorzugen</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
index 26e4894cb76cd..60b4ae0cd42f8 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Preferir “is null” para comprobaciones de igualdad de referencias</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferir coincidencia de patrones</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
index 5b98d2c024953..46d4e596b2dd4 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Préférer 'is nul' pour les vérifications d'égalité de référence</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Préférer les critères spéciaux</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
index f7c2cad124934..11b64a1b14483 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Preferisci 'is null' per i controlli di uguaglianza dei riferimenti</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferisci i criteri di ricerca</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
index f3ef968687913..cecf7812a142f 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
@@ -122,6 +122,11 @@
         <target state="translated">参照の等値性のチェックには 'is null' を優先する</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">パターン マッチングを優先する</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
index e87fdf18182d5..4a568dd1e004b 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
@@ -122,6 +122,11 @@
         <target state="translated">참조 같음 검사에 대해 'is null' 선호</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">패턴 일치 선호</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
index 0899eae4a2035..079f151946fd7 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Preferuj wyrażenie „is null” w przypadku sprawdzeń odwołań pod kątem równości</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferuj dopasowywanie do wzorca</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
index 43527d65a3b0d..afb037c984b51 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Preferir 'is null' para as verificações de igualdade de referência</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferir a correspondência de padrões</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
index a32c43edda66e..5b284d87e3beb 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Использовать "is null" вместо проверки ссылок на равенство.</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Предпочитать соответствие шаблону</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
index 65cd8caa4d2b8..f36be771b8a70 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Başvuru eşitliği denetimleri için 'is null'ı tercih et</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Desen eşleştirmeyi tercih et</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
index 6694126dc85fa..7d200d4f2e050 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
@@ -122,6 +122,11 @@
         <target state="translated">引用相等检查偏好 “is null”</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">首选模式匹配</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
index c23c57609349a..656e68e1a6e94 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
@@ -122,6 +122,11 @@
         <target state="translated">參考相等檢查最好使用 'is null'</target>
         <note>'is null' is a C# string and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Prefer_null_check_over_type_check">
+        <source>Prefer 'null' check over type check</source>
+        <target state="new">Prefer 'null' check over type check</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">建議使用模式比對</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
index 5ceecaa1ec191..e6e55db2caa55 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">Zobrazovat vložené nápovědy;
 Zobrazit diagnostiku pro zavřené soubory;
 Vybarvit regulární výraz; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
index ec058fb7caf1b..b5ad74ac5834c 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">Inlinehinweise anzeigen;
 Diagnoseinformationen für geschlossene Dateien anzeigen;
 Reguläre Ausdrücke farbig hervorheben;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
index 79041ce406cea..68b0b945a7305 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">Mostrar sugerencias insertadas;
 Mostrar diagnóstico para archivos cerrados;
 Colorear expresión regular; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
index 60533c2835efe..5336e5ec7aa05 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">Afficher les indicateurs inline ;
 Afficher les diagnostics pour les fichiers fermés ;
 Mettre en couleurs l'expression régulière ; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
index 18600b271474a..6991c05f5ff10 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">Visualizza suggerimenti inline;
 Mostra diagnostica per file chiusi;
 Colora espressione regolare; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
index d80ccb3217566..04f90e6bf6371 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">インラインのヒントを表示する;
 閉じているファイルの診断結果を表示する;
 正規表現をカラー化する;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
index e08d82d4fbf68..b198ec7fe5b06 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">인라인 힌트 표시;
 닫힌 파일에 대한 진단 표시;
 정규식 색 지정, 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
index 1e0ac9a636259..d6435ffa1e693 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">Wyświetlaj wskazówki w tekście;
 Pokaż dane diagnostyczne dla zamkniętych plików;
 Koloruj wyrażenia regularne; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
index 8193368f22710..4a258a0fba38c 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">Exibir as dicas embutidas;
 Mostrar os diagnósticos de arquivos fechados;
 Colorir a expressão regular; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
index 8db36cfa8dba9..c6707c64bbd54 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">Отображать встроенные подсказки;
 Отображать диагностику для закрытых файлов;
 Выделять регулярные выражения цветом; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
index 20dda4691f5cf..c46a7f5a8da08 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">Satır içi ipuçlarını göster;
 Kapatılan dosyalara ilişkin tanılamaları göster;
 Normal ifadeyi renklendir; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
index 7192bb466f6d9..0356f99c0c477 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">显示内联提示;
 显示对已关闭文件的诊断;
 对正则表达式着色;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
index 44ee0c2b86226..33daee66f28c8 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
@@ -81,7 +81,8 @@ prefer auto properties;
 regex;
 regular expression;
 Use enhanced colors;
-Editor Color Scheme;</source>
+Editor Color Scheme;
+Inheritance Margin;</source>
         <target state="needs-review-translation">顯示內嵌提示;
 顯示已關閉檔案的診斷;
 為規則運算式著色; 
diff --git a/src/VisualStudio/CSharp/Test/Interactive/Commands/ResetInteractiveTests.cs b/src/VisualStudio/CSharp/Test/Interactive/Commands/ResetInteractiveTests.cs
index 39e463281d2cc..0b6a6abbf4ba7 100644
--- a/src/VisualStudio/CSharp/Test/Interactive/Commands/ResetInteractiveTests.cs
+++ b/src/VisualStudio/CSharp/Test/Interactive/Commands/ResetInteractiveTests.cs
@@ -122,6 +122,7 @@ private async Task AssertResetInteractiveAsync(
             {
                 expectedSubmissions.AddRange(expectedReferences.Select(r => r + newLineCharacter));
             }
+
             if (expectedUsings.Any())
             {
                 expectedSubmissions.Add(string.Join(newLineCharacter, expectedUsings) + newLineCharacter);
diff --git a/src/VisualStudio/CSharp/Test/PersistentStorage/AbstractPersistentStorageTests.cs b/src/VisualStudio/CSharp/Test/PersistentStorage/AbstractPersistentStorageTests.cs
index 09ffc4b65775b..d760162eb2f23 100644
--- a/src/VisualStudio/CSharp/Test/PersistentStorage/AbstractPersistentStorageTests.cs
+++ b/src/VisualStudio/CSharp/Test/PersistentStorage/AbstractPersistentStorageTests.cs
@@ -14,6 +14,7 @@
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PersistentStorage;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Storage;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.VisualStudio.LanguageServices.UnitTests;
@@ -841,6 +842,7 @@ private void DoSimultaneousReads(Func<Task<string>> read, string expectedValue)
                             exceptions.Add(ex);
                         }
                     }
+
                     countdown.Signal();
                 });
             }
@@ -873,6 +875,7 @@ private void DoSimultaneousWrites(Func<string, Task> write)
                             exceptions.Add(ex);
                         }
                     }
+
                     countdown.Signal();
                 }, i);
             }
diff --git a/src/VisualStudio/CSharp/Test/PersistentStorage/SQLiteV2PersistentStorageTests.cs b/src/VisualStudio/CSharp/Test/PersistentStorage/SQLiteV2PersistentStorageTests.cs
index 06976afc94576..5680a104422e0 100644
--- a/src/VisualStudio/CSharp/Test/PersistentStorage/SQLiteV2PersistentStorageTests.cs
+++ b/src/VisualStudio/CSharp/Test/PersistentStorage/SQLiteV2PersistentStorageTests.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SQLite.v2;
 using Microsoft.CodeAnalysis.Storage;
 using Xunit;
@@ -23,7 +24,12 @@ namespace Microsoft.CodeAnalysis.UnitTests.WorkspaceServices
     public class SQLiteV2PersistentStorageTests : AbstractPersistentStorageTests
     {
         internal override AbstractPersistentStorageService GetStorageService(OptionSet options, IMefHostExportProvider exportProvider, IPersistentStorageLocationService locationService, IPersistentStorageFaultInjector? faultInjector, string relativePathBase)
-            => new SQLitePersistentStorageService(options, exportProvider.GetExports<SQLiteConnectionPoolService>().Single().Value, locationService, faultInjector);
+            => new SQLitePersistentStorageService(
+                options,
+                exportProvider.GetExports<SQLiteConnectionPoolService>().Single().Value,
+                locationService,
+                exportProvider.GetExports<IAsynchronousOperationListenerProvider>().Single().Value.GetListener(FeatureAttribute.PersistentStorage),
+                faultInjector);
 
         [Fact]
         public async Task TestCrashInNewConnection()
diff --git a/src/VisualStudio/Core/Def/Commands.vsct b/src/VisualStudio/Core/Def/Commands.vsct
index 422b93c7d0bfd..40fdb4225579d 100644
--- a/src/VisualStudio/Core/Def/Commands.vsct
+++ b/src/VisualStudio/Core/Def/Commands.vsct
@@ -411,6 +411,19 @@
           <LocCanonicalName>RemoveUnusedReferences</LocCanonicalName>
         </Strings>
       </Button>
+
+      <Button guid="guidRoslynGrpId" id="cmdidshowValueTracking" priority="0x0203" type="Button">
+        <Parent guid="guidSHLMainMenu" id="IDG_VS_EDIT_GOTO"/>
+        <CommandFlag>DynamicVisibility</CommandFlag>
+        <CommandFlag>DefaultInvisible</CommandFlag>
+        <CommandFlag>CommandWellOnly</CommandFlag>
+        <Strings>
+          <ButtonText>Track Value Source</ButtonText>
+          <CommandName>ShowValueTrackingCommandName</CommandName>
+          <CanonicalName>ShowValueTracking</CanonicalName>
+          <LocCanonicalName>ViewEditorConfigSettings</LocCanonicalName>
+        </Strings>
+      </Button>
     </Buttons>
 
     <Menus>
@@ -516,6 +529,10 @@
     <CommandPlacement guid="guidRoslynGrpId" id="cmdidRemoveUnusedReferences" priority="0xF200">
       <Parent guid="guidSHLMainMenu" id="IDG_VS_CTXT_REFROOT_ADD" />
     </CommandPlacement>
+  
+    <CommandPlacement guid="guidRoslynGrpId" id="cmdidshowValueTracking" priority="0xF200">
+      <Parent guid="guidSHLMainMenu" id="IDG_VS_CODEWIN_NAVIGATETOLOCATION"/>
+    </CommandPlacement>
   </CommandPlacements>
 
   <KeyBindings>
@@ -601,6 +618,8 @@
       <IDSymbol name="cmdidRunCodeAnalysisForProject"  value="0x0201" />
 
       <IDSymbol name="cmdidRemoveUnusedReferences" value="0x202" />
+    
+      <IDSymbol name="cmdidshowValueTracking"  value="0x0203" />
     </GuidSymbol>
 
     <GuidSymbol name="guidCSharpInteractiveCommandSet" value="{1492db0a-85a2-4e43-bf0d-ce55b89a8cc6}">
diff --git a/src/VisualStudio/Core/Def/EditorConfigSettings/Common/EditorTextUpdater.cs b/src/VisualStudio/Core/Def/EditorConfigSettings/Common/EditorTextUpdater.cs
index ed941cfef95a7..0bb2230665580 100644
--- a/src/VisualStudio/Core/Def/EditorConfigSettings/Common/EditorTextUpdater.cs
+++ b/src/VisualStudio/Core/Def/EditorConfigSettings/Common/EditorTextUpdater.cs
@@ -32,6 +32,7 @@ public void UpdateText(IReadOnlyList<TextChange> changes)
             {
                 return;
             }
+
             TextEditApplication.UpdateText(changes.ToImmutableArray(), buffer, EditOptions.DefaultMinimalChange);
         }
     }
diff --git a/src/VisualStudio/Core/Def/EditorConfigSettings/Formatting/View/ColumnDefnitions/FormattingValueColumnDefinition.cs b/src/VisualStudio/Core/Def/EditorConfigSettings/Formatting/View/ColumnDefnitions/FormattingValueColumnDefinition.cs
index 48128122cc5b2..ccaed8345d11f 100644
--- a/src/VisualStudio/Core/Def/EditorConfigSettings/Formatting/View/ColumnDefnitions/FormattingValueColumnDefinition.cs
+++ b/src/VisualStudio/Core/Def/EditorConfigSettings/Formatting/View/ColumnDefnitions/FormattingValueColumnDefinition.cs
@@ -44,6 +44,7 @@ public override bool TryCreateColumnContent(ITableEntryHandle entry, bool single
                 content = null;
                 return false;
             }
+
             if (setting.Type == typeof(bool))
             {
                 content = new FormattingBoolSettingView(setting);
diff --git a/src/VisualStudio/Core/Def/EditorConfigSettings/SettingsEditorPane.cs b/src/VisualStudio/Core/Def/EditorConfigSettings/SettingsEditorPane.cs
index ebb94d37e7329..89268b2a5dd0f 100644
--- a/src/VisualStudio/Core/Def/EditorConfigSettings/SettingsEditorPane.cs
+++ b/src/VisualStudio/Core/Def/EditorConfigSettings/SettingsEditorPane.cs
@@ -122,6 +122,7 @@ ISettingsEditorView GetFormattingView()
                 {
                     throw new InvalidOperationException("Unable to get formatter settings");
                 }
+
                 var viewModel = new FormattingViewModel(dataProvider, _controlProvider, _tableMangerProvider);
                 return new FormattingSettingsView(viewModel);
             }
@@ -133,6 +134,7 @@ ISettingsEditorView GetCodeStyleView()
                 {
                     throw new InvalidOperationException("Unable to get code style settings");
                 }
+
                 var viewModel = new CodeStyleSettingsViewModel(dataProvider, _controlProvider, _tableMangerProvider);
                 return new CodeStyleSettingsView(viewModel);
             }
@@ -240,6 +242,7 @@ public int FDoIdle(uint grfidlef)
             {
                 _control.SynchronizeSettings();
             }
+
             return S_OK;
         }
 
diff --git a/src/VisualStudio/Core/Def/Guids.cs b/src/VisualStudio/Core/Def/Guids.cs
index 6f058e3c50002..994acb0fbbebc 100644
--- a/src/VisualStudio/Core/Def/Guids.cs
+++ b/src/VisualStudio/Core/Def/Guids.cs
@@ -125,6 +125,9 @@ internal static class Guids
         public static readonly Guid RoslynCommandSetId = new(RoslynCommandSetIdString);
         public static readonly Guid RoslynGroupId = new(RoslynGroupIdString);
 
+        public const string ValueTrackingToolWindowIdString = "60a19d42-2dd7-43f3-be90-c7a9cb7d28f4";
+        public static readonly Guid ValueTrackingToolWindowId = new(ValueTrackingToolWindowIdString);
+
         // TODO: Remove pending https://github.com/dotnet/roslyn/issues/8927 .
         // Interactive guids
         public const string InteractiveCommandSetIdString = "00B8868B-F9F5-4970-A048-410B05508506";
diff --git a/src/VisualStudio/Core/Def/ID.RoslynCommands.cs b/src/VisualStudio/Core/Def/ID.RoslynCommands.cs
index d89285327286e..ad65fd8e87b1f 100644
--- a/src/VisualStudio/Core/Def/ID.RoslynCommands.cs
+++ b/src/VisualStudio/Core/Def/ID.RoslynCommands.cs
@@ -50,6 +50,7 @@ public static class RoslynCommands
 
             public const int RunCodeAnalysisForProject = 0x0201;
             public const int RemoveUnusedReferences = 0x0202;
+            public const int GoToValueTrackingWindow = 0x0203;
         }
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/ChangeSignature/ChangeSignatureDialogViewModel.ParameterViewModels.cs b/src/VisualStudio/Core/Def/Implementation/ChangeSignature/ChangeSignatureDialogViewModel.ParameterViewModels.cs
index 4f5be59c9102f..ac655f93c7d32 100644
--- a/src/VisualStudio/Core/Def/Implementation/ChangeSignature/ChangeSignatureDialogViewModel.ParameterViewModels.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ChangeSignature/ChangeSignatureDialogViewModel.ParameterViewModels.cs
@@ -233,6 +233,7 @@ public override string Default
                         case LanguageNames.VisualBasic:
                             return NullText("Nothing", "Nothing");
                     }
+
                     return string.Empty;
 
                     string NullText(string @null, string @default)
diff --git a/src/VisualStudio/Core/Def/Implementation/CommandBindings.cs b/src/VisualStudio/Core/Def/Implementation/CommandBindings.cs
index 27a6efccbd0ea..b2992efa119ab 100644
--- a/src/VisualStudio/Core/Def/Implementation/CommandBindings.cs
+++ b/src/VisualStudio/Core/Def/Implementation/CommandBindings.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.Editor.Commanding.Commands;
 using Microsoft.VisualStudio.Editor.Commanding;
 using Microsoft.VisualStudio.LanguageServices;
+using Microsoft.VisualStudio.LanguageServices.ValueTracking;
 
 namespace Microsoft.VisualStudio.Editor.Implementation
 {
@@ -28,5 +29,9 @@ internal sealed class CommandBindings
         [Export]
         [CommandBinding(Guids.CSharpGroupIdString, ID.CSharpCommands.ContextOrganizeRemoveAndSort, typeof(SortAndRemoveUnnecessaryImportsCommandArgs))]
         internal CommandBindingDefinition contextOrganizeRemoveAndSortCommandBinding;
+
+        [Export]
+        [CommandBinding(Guids.RoslynGroupIdString, ID.RoslynCommands.GoToValueTrackingWindow, typeof(ValueTrackingEditorCommandArgs))]
+        internal CommandBindingDefinition gotoDataFlowToolCommandBinding;
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/VisualStudioDesignerAttributeService.cs b/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/VisualStudioDesignerAttributeService.cs
index 05015c4ebea93..52df9e1854c5e 100644
--- a/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/VisualStudioDesignerAttributeService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/VisualStudioDesignerAttributeService.cs
@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.VisualStudio.Designer.Interfaces;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
@@ -66,6 +67,7 @@ internal class VisualStudioDesignerAttributeService
         public VisualStudioDesignerAttributeService(
             VisualStudioWorkspaceImpl workspace,
             IThreadingContext threadingContext,
+            IAsynchronousOperationListenerProvider asynchronousOperationListenerProvider,
             Shell.SVsServiceProvider serviceProvider)
             : base(threadingContext)
         {
@@ -75,6 +77,7 @@ public VisualStudioDesignerAttributeService(
             _workQueue = new AsyncBatchingWorkQueue<DesignerAttributeData>(
                 TimeSpan.FromSeconds(1),
                 this.NotifyProjectSystemAsync,
+                asynchronousOperationListenerProvider.GetListener(FeatureAttribute.DesignerAttributes),
                 ThreadingContext.DisposalToken);
         }
 
@@ -143,7 +146,7 @@ public void StartScanningForDesignerAttributesInCurrentProcess(CancellationToken
                     workspaceKinds: WorkspaceKind.Host));
         }
 
-        private async Task NotifyProjectSystemAsync(
+        private async ValueTask NotifyProjectSystemAsync(
             ImmutableArray<DesignerAttributeData> data, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
diff --git a/src/VisualStudio/Core/Def/Implementation/EditAndContinue/ManagedEditAndContinueLanguageService.cs b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/ManagedEditAndContinueLanguageService.cs
index 663e1bc86c070..10f0351999e98 100644
--- a/src/VisualStudio/Core/Def/Implementation/EditAndContinue/ManagedEditAndContinueLanguageService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/ManagedEditAndContinueLanguageService.cs
@@ -186,9 +186,15 @@ public async Task<bool> HasChangesAsync(string? sourceFilePath, CancellationToke
         {
             try
             {
+                var debuggingSession = _debuggingSession;
+                if (debuggingSession == null)
+                {
+                    return false;
+                }
+
                 var solution = GetCurrentCompileTimeSolution();
                 var activeStatementSpanProvider = GetActiveStatementSpanProvider(solution);
-                return await GetDebuggingSession().HasChangesAsync(solution, activeStatementSpanProvider, sourceFilePath, cancellationToken).ConfigureAwait(false);
+                return await debuggingSession.HasChangesAsync(solution, activeStatementSpanProvider, sourceFilePath, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
             {
diff --git a/src/VisualStudio/Core/Def/Implementation/EditAndContinue/ManagedHotReloadLanguageService.cs b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/ManagedHotReloadLanguageService.cs
index 06e156a4c3b0c..e9a5c2fa869f1 100644
--- a/src/VisualStudio/Core/Def/Implementation/EditAndContinue/ManagedHotReloadLanguageService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/ManagedHotReloadLanguageService.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.ErrorReporting;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
@@ -78,6 +79,9 @@ private RemoteDebuggingSessionProxy GetDebuggingSession()
             return debuggingSession;
         }
 
+        private Solution GetCurrentCompileTimeSolution()
+            => _proxy.Workspace.Services.GetRequiredService<ICompileTimeSolutionProvider>().GetCompileTimeSolution(_proxy.Workspace.CurrentSolution);
+
         public async ValueTask StartSessionAsync(CancellationToken cancellationToken)
         {
             if (_disabled)
@@ -87,7 +91,7 @@ public async ValueTask StartSessionAsync(CancellationToken cancellationToken)
 
             try
             {
-                var solution = _proxy.Workspace.CurrentSolution;
+                var solution = GetCurrentCompileTimeSolution();
                 _debuggingSession = await _proxy.StartDebuggingSessionAsync(solution, _debuggerService, captureMatchingDocuments: false, reportDiagnostics: true, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
@@ -107,7 +111,7 @@ public async ValueTask<ManagedHotReloadUpdates> GetUpdatesAsync(CancellationToke
 
             try
             {
-                var solution = _proxy.Workspace.CurrentSolution;
+                var solution = GetCurrentCompileTimeSolution();
                 var (moduleUpdates, diagnosticData, rudeEdits) = await GetDebuggingSession().EmitSolutionUpdateAsync(solution, s_solutionActiveStatementSpanProvider, _diagnosticService, _diagnosticUpdateSource, cancellationToken).ConfigureAwait(false);
 
                 var updates = moduleUpdates.Updates.SelectAsArray(
diff --git a/src/VisualStudio/Core/Def/Implementation/EditAndContinue/VisualStudioWorkspaceEditAndContinueListener.cs b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/VisualStudioWorkspaceEditAndContinueListener.cs
new file mode 100644
index 0000000000000..bd737a536714d
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/VisualStudioWorkspaceEditAndContinueListener.cs
@@ -0,0 +1,56 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Roslyn.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.EditAndContinue
+{
+    /// <summary>
+    /// Connects <see cref="VisualStudioWorkspace"/> to the ServiceHub services.
+    /// Launches ServiceHub if it is not running yet and starts services that push information from <see cref="VisualStudioWorkspace"/> to the ServiceHub process.
+    /// </summary>
+    [ExportEventListener(WellKnownEventListeners.Workspace, WorkspaceKind.Host), Shared]
+    internal sealed class VisualStudioWorkspaceEditAndContinueListener : IEventListener<object>, IEventListenerStoppable
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public VisualStudioWorkspaceEditAndContinueListener()
+        {
+        }
+
+        public void StartListening(Workspace workspace, object serviceOpt)
+        {
+            if (workspace is not VisualStudioWorkspace)
+            {
+                return;
+            }
+
+            workspace.DocumentOpened += WorkspaceDocumentOpened;
+        }
+
+        public void StopListening(Workspace workspace)
+        {
+            if (workspace is not VisualStudioWorkspace)
+            {
+                return;
+            }
+
+            workspace.DocumentOpened -= WorkspaceDocumentOpened;
+        }
+
+        private void WorkspaceDocumentOpened(object? sender, DocumentEventArgs e)
+        {
+            var proxy = new RemoteEditAndContinueServiceProxy(e.Document.Project.Solution.Workspace);
+            _ = Task.Run(() => proxy.OnSourceFileUpdatedAsync(e.Document, CancellationToken.None)).ReportNonFatalErrorAsync();
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
index 1ec25628cadec..c2f51fd3e1b48 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
@@ -143,6 +143,7 @@ protected AbstractTableDataSourceFindUsagesContext(
                 _progressQueue = new AsyncBatchingWorkQueue<(int current, int maximum)>(
                     TimeSpan.FromMilliseconds(250),
                     this.UpdateTableProgressAsync,
+                    presenter._asyncListener,
                     CancellationTokenSource.Token);
             }
 
@@ -406,7 +407,7 @@ protected sealed override ValueTask ReportProgressAsync(int current, int maximum
                 return default;
             }
 
-            private Task UpdateTableProgressAsync(ImmutableArray<(int current, int maximum)> nextBatch, CancellationToken _)
+            private ValueTask UpdateTableProgressAsync(ImmutableArray<(int current, int maximum)> nextBatch, CancellationToken _)
             {
                 if (!nextBatch.IsEmpty)
                 {
@@ -426,7 +427,7 @@ private Task UpdateTableProgressAsync(ImmutableArray<(int current, int maximum)>
                         _findReferencesWindow.SetProgress(current, maximum);
                 }
 
-                return Task.CompletedTask;
+                return ValueTaskFactory.CompletedTask;
             }
 
             #endregion
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/StreamingFindUsagesPresenter.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/StreamingFindUsagesPresenter.cs
index 63db39ae31c06..bab65db029281 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/StreamingFindUsagesPresenter.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/StreamingFindUsagesPresenter.cs
@@ -16,6 +16,7 @@
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.LanguageServices.Implementation.FindReferences;
 using Microsoft.VisualStudio.Shell.FindAllReferences;
 using Microsoft.VisualStudio.Shell.TableControl;
@@ -38,6 +39,7 @@ internal partial class StreamingFindUsagesPresenter :
 
         public readonly ClassificationTypeMap TypeMap;
         public readonly IEditorFormatMapService FormatMapService;
+        private readonly IAsynchronousOperationListener _asyncListener;
         public readonly IClassificationFormatMap ClassificationFormatMap;
 
         private readonly Workspace _workspace;
@@ -55,6 +57,7 @@ public StreamingFindUsagesPresenter(
             ClassificationTypeMap typeMap,
             IEditorFormatMapService formatMapService,
             IClassificationFormatMapService classificationFormatMapService,
+            IAsynchronousOperationListenerProvider asynchronousOperationListenerProvider,
             [ImportMany] IEnumerable<Lazy<ITableColumnDefinition, NameMetadata>> columns)
             : this(workspace,
                    threadingContext,
@@ -62,7 +65,8 @@ public StreamingFindUsagesPresenter(
                    typeMap,
                    formatMapService,
                    classificationFormatMapService,
-                   GetCustomColumns(columns))
+                   GetCustomColumns(columns),
+                   asynchronousOperationListenerProvider)
         {
         }
 
@@ -77,7 +81,8 @@ public StreamingFindUsagesPresenter(
                   exportProvider.GetExportedValue<ClassificationTypeMap>(),
                   exportProvider.GetExportedValue<IEditorFormatMapService>(),
                   exportProvider.GetExportedValue<IClassificationFormatMapService>(),
-                  exportProvider.GetExportedValues<ITableColumnDefinition>())
+                  exportProvider.GetExportedValues<ITableColumnDefinition>(),
+                  exportProvider.GetExportedValue<IAsynchronousOperationListenerProvider>())
         {
         }
 
@@ -89,13 +94,15 @@ private StreamingFindUsagesPresenter(
             ClassificationTypeMap typeMap,
             IEditorFormatMapService formatMapService,
             IClassificationFormatMapService classificationFormatMapService,
-            IEnumerable<ITableColumnDefinition> columns)
+            IEnumerable<ITableColumnDefinition> columns,
+            IAsynchronousOperationListenerProvider asyncListenerProvider)
             : base(threadingContext, assertIsForeground: false)
         {
             _workspace = workspace;
             _serviceProvider = serviceProvider;
             TypeMap = typeMap;
             FormatMapService = formatMapService;
+            _asyncListener = asyncListenerProvider.GetListener(FeatureAttribute.FindReferences);
             ClassificationFormatMap = classificationFormatMapService.GetClassificationFormatMap("tooltip");
 
             _customColumns = columns.ToImmutableArray();
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphFactory.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphFactory.cs
index f1184deabce3d..9ee34cd9affe9 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphFactory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphFactory.cs
@@ -45,9 +45,6 @@ public InheritanceGlyphFactory(
                 var membersOnLine = inheritanceMarginTag.MembersOnLine;
                 Contract.ThrowIfTrue(membersOnLine.IsEmpty);
 
-                // ZoomLevel of textView is percentage based. (e.g. 20 -> 400 means 20% -> 400%)
-                // and the scaleFactor of CrispImage is 1 based. (e.g 1 means 100%)
-                var scaleFactor = _textView.ZoomLevel / 100;
                 return new MarginGlyph.InheritanceMargin(
                     _threadingContext,
                     _streamingFindUsagesPresenter,
@@ -55,7 +52,7 @@ public InheritanceGlyphFactory(
                     _classificationFormatMap,
                     _operationExecutor,
                     inheritanceMarginTag,
-                    scaleFactor);
+                    _textView);
             }
 
             return null;
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginHelpers.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginHelpers.cs
index 34a15b3a44a30..d9a665b4283c7 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginHelpers.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginHelpers.cs
@@ -16,100 +16,78 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMarg
 {
     internal static class InheritanceMarginHelpers
     {
+        private static readonly ImmutableArray<InheritanceRelationship> s_relationships_Shown_As_I_Up_Arrow
+            = ImmutableArray<InheritanceRelationship>.Empty
+            .Add(InheritanceRelationship.ImplementedInterface)
+            .Add(InheritanceRelationship.InheritedInterface)
+            .Add(InheritanceRelationship.ImplementedMember);
+
+        private static readonly ImmutableArray<InheritanceRelationship> s_relationships_Shown_As_I_Down_Arrow
+            = ImmutableArray<InheritanceRelationship>.Empty
+            .Add(InheritanceRelationship.ImplementingType)
+            .Add(InheritanceRelationship.ImplementingMember);
+
+        private static readonly ImmutableArray<InheritanceRelationship> s_relationships_Shown_As_O_Up_Arrow
+            = ImmutableArray<InheritanceRelationship>.Empty
+            .Add(InheritanceRelationship.BaseType)
+            .Add(InheritanceRelationship.OverriddenMember);
+
+        private static readonly ImmutableArray<InheritanceRelationship> s_relationships_Shown_As_O_Down_Arrow
+            = ImmutableArray<InheritanceRelationship>.Empty
+            .Add(InheritanceRelationship.DerivedType)
+            .Add(InheritanceRelationship.OverridingMember);
+
         /// <summary>
         /// Decide which moniker should be shown.
         /// </summary>
         public static ImageMoniker GetMoniker(InheritanceRelationship inheritanceRelationship)
         {
             //  If there are multiple targets and we have the corresponding compound image, use it
-            if (inheritanceRelationship.HasFlag(InheritanceRelationship.ImplementingOverriding))
+            if (s_relationships_Shown_As_I_Up_Arrow.Any(flag => inheritanceRelationship.HasFlag(flag))
+                && s_relationships_Shown_As_O_Down_Arrow.Any(flag => inheritanceRelationship.HasFlag(flag)))
             {
-                return KnownMonikers.ImplementingOverriding;
+                return KnownMonikers.ImplementingOverridden;
             }
 
-            if (inheritanceRelationship.HasFlag(InheritanceRelationship.ImplementingOverridden))
+            if (s_relationships_Shown_As_I_Up_Arrow.Any(flag => inheritanceRelationship.HasFlag(flag))
+                && s_relationships_Shown_As_O_Up_Arrow.Any(flag => inheritanceRelationship.HasFlag(flag)))
             {
-                return KnownMonikers.ImplementingOverridden;
+                return KnownMonikers.ImplementingOverriding;
             }
 
             // Otherwise, show the image based on this preference
-            if (inheritanceRelationship.HasFlag(InheritanceRelationship.Implemented))
+            if (s_relationships_Shown_As_I_Up_Arrow.Any(flag => inheritanceRelationship.HasFlag(flag)))
             {
-                return KnownMonikers.Implemented;
+                return KnownMonikers.Implementing;
             }
 
-            if (inheritanceRelationship.HasFlag(InheritanceRelationship.Implementing))
+            if (s_relationships_Shown_As_I_Down_Arrow.Any(flag => inheritanceRelationship.HasFlag(flag)))
             {
-                return KnownMonikers.Implementing;
+                return KnownMonikers.Implemented;
             }
 
-            if (inheritanceRelationship.HasFlag(InheritanceRelationship.Overridden))
+            if (s_relationships_Shown_As_O_Up_Arrow.Any(flag => inheritanceRelationship.HasFlag(flag)))
             {
-                return KnownMonikers.Overridden;
+                return KnownMonikers.Overriding;
             }
 
-            if (inheritanceRelationship.HasFlag(InheritanceRelationship.Overriding))
+            if (s_relationships_Shown_As_O_Down_Arrow.Any(flag => inheritanceRelationship.HasFlag(flag)))
             {
-                return KnownMonikers.Overriding;
+                return KnownMonikers.Overridden;
             }
 
             // The relationship is None. Don't know what image should be shown, throws
             throw ExceptionUtilities.UnexpectedValue(inheritanceRelationship);
         }
 
-        /// <summary>
-        /// Create the view models for the inheritance targets of a single member.
-        /// There are two cases:
-        /// 1. If all the targets have the same inheritance relationship. It would be an array of TargetViewModel
-        /// e.g.
-        /// Target1ViewModel
-        /// Target2ViewModel
-        /// Target3ViewModel
-        ///
-        /// 2. If targets belongs to different inheritance group. It would be grouped.
-        /// e.g.
-        /// Header1ViewModel
-        /// Target1ViewModel
-        /// Target2ViewModel
-        /// Header2ViewModel
-        /// Target1ViewModel
-        /// Target2ViewModel
-        /// </summary>
         public static ImmutableArray<InheritanceMenuItemViewModel> CreateMenuItemViewModelsForSingleMember(ImmutableArray<InheritanceTargetItem> targets)
-        {
-            var targetsByRelationship = targets.OrderBy(target => target.DisplayName).GroupBy(target => target.RelationToMember)
-                .ToImmutableDictionary(
-                    keySelector: grouping => grouping.Key,
-                    elementSelector: grouping => grouping);
-            if (targetsByRelationship.Count == 1)
-            {
-                // If all targets have one relationship.
-                // e.g. interface IBar { void Bar(); }
-                // class A : IBar { void Bar() {} }
-                // class B : IBar { void Bar() {} }
-                // for 'IBar', the margin would be I↓. So header is not needed.
-                var (_, targetItems) = targetsByRelationship.Single();
-                return targetItems.SelectAsArray(target => TargetMenuItemViewModel.Create(target, indent: false)).CastArray<InheritanceMenuItemViewModel>();
-            }
-            else
-            {
-                // Otherwise, it means these targets has different relationship,
-                // these targets would be shown in group, and a header should be shown as the first item to indicate the relationship to user.
-                return targetsByRelationship.SelectMany(kvp => CreateMenuItemsWithHeader(kvp.Key, kvp.Value)).ToImmutableArray();
-            }
-        }
+            => targets.OrderBy(target => target.DisplayName)
+                .GroupBy(target => target.RelationToMember)
+                .SelectMany(grouping => CreateMenuItemsWithHeader(grouping.Key, grouping))
+                .ToImmutableArray();
 
         /// <summary>
         /// Create the view models for the inheritance targets of multiple members
-        /// There are two cases:
-        /// 1. If all the targets have the same inheritance relationship. It would have this structure:
-        /// e.g.
-        /// MemberViewModel1 -> Target1ViewModel
-        ///                     Target2ViewModel
-        /// MemberViewModel2 -> Target4ViewModel
-        ///                     Target5ViewModel
-        ///
-        /// 2. If targets belongs to different inheritance group. It would be grouped.
         /// e.g.
         /// MemberViewModel1 -> HeaderViewModel
         ///                     Target1ViewModel
@@ -126,17 +104,7 @@ public static ImmutableArray<InheritanceMenuItemViewModel> CreateMenuItemViewMod
             // For multiple members, check if all the targets have the same inheritance relationship.
             // If so, then don't add the header, because it is already indicated by the margin.
             // Otherwise, add the Header.
-            var set = members
-                .SelectMany(member => member.TargetItems.Select(item => item.RelationToMember))
-                .ToImmutableHashSet();
-            if (set.Count == 1)
-            {
-                return members.SelectAsArray(MemberMenuItemViewModel.CreateWithNoHeaderInTargets).CastArray<InheritanceMenuItemViewModel>();
-            }
-            else
-            {
-                return members.SelectAsArray(MemberMenuItemViewModel.CreateWithHeaderInTargets).CastArray<InheritanceMenuItemViewModel>();
-            }
+            return members.SelectAsArray(MemberMenuItemViewModel.CreateWithHeaderInTargets).CastArray<InheritanceMenuItemViewModel>();
         }
 
         public static ImmutableArray<InheritanceMenuItemViewModel> CreateMenuItemsWithHeader(
@@ -146,10 +114,15 @@ public static ImmutableArray<InheritanceMenuItemViewModel> CreateMenuItemsWithHe
             using var _ = CodeAnalysis.PooledObjects.ArrayBuilder<InheritanceMenuItemViewModel>.GetInstance(out var builder);
             var displayContent = relationship switch
             {
-                InheritanceRelationship.Implemented => ServicesVSResources.Implemented_members,
-                InheritanceRelationship.Implementing => ServicesVSResources.Implementing_members,
-                InheritanceRelationship.Overriding => ServicesVSResources.Overriding_members,
-                InheritanceRelationship.Overridden => ServicesVSResources.Overridden_members,
+                InheritanceRelationship.ImplementedInterface => ServicesVSResources.Implemented_interfaces,
+                InheritanceRelationship.BaseType => ServicesVSResources.Base_Types,
+                InheritanceRelationship.DerivedType => ServicesVSResources.Derived_types,
+                InheritanceRelationship.InheritedInterface => ServicesVSResources.Inherited_interfaces,
+                InheritanceRelationship.ImplementingType => ServicesVSResources.Implementing_types,
+                InheritanceRelationship.ImplementedMember => ServicesVSResources.Implemented_members,
+                InheritanceRelationship.OverriddenMember => ServicesVSResources.Overridden_members,
+                InheritanceRelationship.OverridingMember => ServicesVSResources.Overriding_members,
+                InheritanceRelationship.ImplementingMember => ServicesVSResources.Implementing_members,
                 _ => throw ExceptionUtilities.UnexpectedValue(relationship)
             };
 
@@ -157,7 +130,7 @@ public static ImmutableArray<InheritanceMenuItemViewModel> CreateMenuItemsWithHe
             builder.Add(headerViewModel);
             foreach (var targetItem in targets)
             {
-                builder.Add(TargetMenuItemViewModel.Create(targetItem, indent: true));
+                builder.Add(TargetMenuItemViewModel.Create(targetItem));
             }
 
             return builder.ToImmutable();
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginTaggerProvider.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginTaggerProvider.cs
index 1a8be7aeef315..7f7357b82ad73 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginTaggerProvider.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginTaggerProvider.cs
@@ -15,8 +15,10 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Editor.Tagging;
+using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.InheritanceMargin;
+using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Text;
@@ -45,6 +47,8 @@ public InheritanceMarginTaggerProvider(
 
         protected override TaggerDelay EventChangeDelay => TaggerDelay.OnIdle;
 
+        private bool? _experimentEnabled = null;
+
         protected override ITaggerEventSource CreateEventSource(ITextView textViewOpt, ITextBuffer subjectBuffer)
             // Because we use frozen-partial documents for semantic classification, we may end up with incomplete
             // semantics (esp. during solution load).  Because of this, we also register to hear when the full
@@ -84,8 +88,16 @@ protected override async Task ProduceTagsAsync(
             var cancellationToken = context.CancellationToken;
 
             var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            var featureEnabled = options.GetOption(FeatureOnOffOptions.ShowInheritanceMargin);
-            if (!featureEnabled)
+
+            var optionIsChecked = options.GetOption(FeatureOnOffOptions.ShowInheritanceMargin);
+            if (_experimentEnabled is null)
+            {
+                var experimentationService = document.Project.Solution.Workspace.Services.GetRequiredService<IExperimentationService>();
+                _experimentEnabled = experimentationService.IsExperimentEnabled(WellKnownExperimentNames.InheritanceMargin);
+            }
+
+            var shouldEnableFeature = optionIsChecked == true || (_experimentEnabled == true && optionIsChecked == null);
+            if (!shouldEnableFeature)
             {
                 return;
             }
@@ -99,10 +111,14 @@ protected override async Task ProduceTagsAsync(
                 return;
             }
 
-            var inheritanceMemberItems = await inheritanceMarginInfoService.GetInheritanceMemberItemsAsync(
+            var inheritanceMemberItems = ImmutableArray<InheritanceMarginItem>.Empty;
+            using (Logger.LogBlock(FunctionId.InheritanceMargin_GetInheritanceMemberItems, cancellationToken, LogLevel.Information))
+            {
+                inheritanceMemberItems = await inheritanceMarginInfoService.GetInheritanceMemberItemsAsync(
                     document,
                     spanToTag.SnapshotSpan.Span.ToTextSpan(),
                     cancellationToken).ConfigureAwait(false);
+            }
 
             if (inheritanceMemberItems.IsEmpty)
             {
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/HeaderMenuItemViewModel.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/HeaderMenuItemViewModel.cs
index c1cc072ae084f..ae8e6d1a71fd8 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/HeaderMenuItemViewModel.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/HeaderMenuItemViewModel.cs
@@ -8,13 +8,9 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMarg
 {
     /// <summary>
     /// The view model used for the header of TargetMenuItemViewModel.
-    /// It is used when the context menu contains targets having multiple inheritance relationship.
-    /// In such case, this would be shown as a header for a group of targets.
     /// e.g.
-    /// 'I↓ Implemented members'
+    /// 'I↓ Implementing members'
     ///       Method 'Bar'
-    /// 'I↑ Implementing members'
-    ///       Method 'Foo'
     /// </summary>
     internal class HeaderMenuItemViewModel : InheritanceMenuItemViewModel
     {
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml
index c93bf9692e9eb..800af9d3f31d2 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml
@@ -115,7 +115,7 @@
                                     </Grid.ColumnDefinitions>
 
                                     <Rectangle Name="Bg" Stroke="Transparent" Fill="Transparent" StrokeThickness="0" Grid.ColumnSpan="5"/>
-                                    <ContentPresenter Grid.Column="0" x:Name="Icon" Margin="{Binding Margin}" Width="16" Height="16" VerticalAlignment="Center"
+                                    <ContentPresenter Grid.Column="0" x:Name="Icon" Margin="22,1,4,1" Width="16" Height="16" VerticalAlignment="Center"
                                                       SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" Content="{TemplateBinding MenuItem.Icon}" />
                                     <ContentPresenter Grid.Column="1" ContentSource="Header" Margin="4,1,4,1"
                                                       VerticalAlignment="Center" RecognizesAccessKey="True" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml.cs
index d2003b6644329..5915c0e02ef00 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml.cs
@@ -16,6 +16,7 @@
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Utilities;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin.MarginGlyph
@@ -26,6 +27,7 @@ internal partial class InheritanceMargin
         private readonly IStreamingFindUsagesPresenter _streamingFindUsagesPresenter;
         private readonly IUIThreadOperationExecutor _operationExecutor;
         private readonly Workspace _workspace;
+        private readonly IWpfTextView _textView;
 
         public InheritanceMargin(
             IThreadingContext threadingContext,
@@ -34,14 +36,18 @@ public InheritanceMargin(
             IClassificationFormatMap classificationFormatMap,
             IUIThreadOperationExecutor operationExecutor,
             InheritanceMarginTag tag,
-            double scaleFactor)
+            IWpfTextView textView)
         {
             _threadingContext = threadingContext;
             _streamingFindUsagesPresenter = streamingFindUsagesPresenter;
             _workspace = tag.Workspace;
             _operationExecutor = operationExecutor;
+            _textView = textView;
             InitializeComponent();
 
+            // ZoomLevel of textView is percentage based. (e.g. 20 -> 400 means 20% -> 400%)
+            // and the scaleFactor of CrispImage is 1 based. (e.g 1 means 100%)
+            var scaleFactor = textView.ZoomLevel;
             var viewModel = InheritanceMarginViewModel.Create(classificationTypeMap, classificationFormatMap, tag, scaleFactor);
             DataContext = viewModel;
             ContextMenu.DataContext = viewModel;
@@ -102,6 +108,9 @@ private void InheritanceMargin_OnMouseLeave(object sender, MouseEventArgs e)
         private void ContextMenu_OnClose(object sender, RoutedEventArgs e)
         {
             ResetBorderToInitialColor();
+            // Move the focus back to textView when the context menu is closed.
+            // It ensures the focus won't be left at the margin
+            ResetFocus();
         }
 
         private void ContextMenu_OnOpen(object sender, RoutedEventArgs e)
@@ -110,13 +119,16 @@ private void ContextMenu_OnOpen(object sender, RoutedEventArgs e)
                 && inheritanceMarginViewModel.MenuItemViewModels.Any(vm => vm is TargetMenuItemViewModel))
             {
                 // We have two kinds of context menu. e.g.
-                // 1. [margin] -> Target1
+                // 1. [margin] -> Header
+                //                Target1
                 //                Target2
                 //                Target3
                 //
-                // 2. [margin] -> method Bar -> Target1
+                // 2. [margin] -> method Bar -> Header
+                //                           -> Target1
                 //                           -> Target2
-                //             -> method Foo -> Target3
+                //             -> method Foo -> Header
+                //                           -> Target3
                 //                           -> Target4
                 // If the first level of the context menu contains a TargetMenuItemViewModel, it means here it is case 1,
                 // user is viewing the targets menu.
@@ -134,5 +146,17 @@ private void ResetBorderToInitialColor()
             this.Background = Brushes.Transparent;
             this.BorderBrush = Brushes.Transparent;
         }
+
+        private void ResetFocus()
+        {
+            if (!_textView.HasAggregateFocus)
+            {
+                var visualElement = _textView.VisualElement;
+                if (visualElement.Focusable)
+                {
+                    Keyboard.Focus(visualElement);
+                }
+            }
+        }
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MemberMenuItemViewModel.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MemberMenuItemViewModel.cs
index b3c55621dda71..49186e2bb773f 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MemberMenuItemViewModel.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MemberMenuItemViewModel.cs
@@ -41,19 +41,6 @@ public MemberMenuItemViewModel(
             Targets = targets;
         }
 
-        public static MemberMenuItemViewModel CreateWithNoHeaderInTargets(InheritanceMarginItem member)
-        {
-            var displayName = member.DisplayTexts.JoinText();
-            return new MemberMenuItemViewModel(
-                displayName,
-                member.Glyph.GetImageMoniker(),
-                displayName,
-                member.TargetItems
-                    .OrderBy(item => item.DisplayName)
-                    .SelectAsArray(item => TargetMenuItemViewModel.Create(item, indent: false))
-                    .CastArray<InheritanceMenuItemViewModel>());
-        }
-
         public static MemberMenuItemViewModel CreateWithHeaderInTargets(InheritanceMarginItem member)
         {
             var displayName = member.DisplayTexts.JoinText();
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/TargetMenuItemViewModel.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/TargetMenuItemViewModel.cs
index d8b553509c76a..a52160126b47b 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/TargetMenuItemViewModel.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/TargetMenuItemViewModel.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Windows;
 using Microsoft.CodeAnalysis.Editor.Wpf;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.InheritanceMargin;
@@ -15,45 +14,22 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMarg
     /// </summary>
     internal class TargetMenuItemViewModel : InheritanceMenuItemViewModel
     {
-        /// <summary>
-        /// The margin for the default case.
-        /// </summary>
-        private static readonly Thickness s_defaultMargin = new Thickness(4, 1, 4, 1);
-
-        /// <summary>
-        /// The margin used when this target item needs to be indented when the target is shown with the header.
-        /// e.g.
-        /// 'I↓ Implemented members'
-        ///       Method 'Bar'
-        /// 'I↑ Implementing members'
-        ///       Method 'Foo'
-        /// It is 22 because the default left margin is 4, and we want to keep the same indentation margin same as solution explorer, which is 18.
-        /// </summary>
-        private static readonly Thickness s_indentMargin = new Thickness(22, 1, 4, 1);
-
         /// <summary>
         /// DefinitionItem used for navigation.
         /// </summary>
         public DefinitionItem DefinitionItem { get; }
 
-        /// <summary>
-        /// Margin for the image moniker.
-        /// </summary>
-        public Thickness Margin { get; }
-
         // Internal for testing purpose
         internal TargetMenuItemViewModel(
             string displayContent,
             ImageMoniker imageMoniker,
             string automationName,
-            DefinitionItem definitionItem,
-            Thickness margin) : base(displayContent, imageMoniker, automationName)
+            DefinitionItem definitionItem) : base(displayContent, imageMoniker, automationName)
         {
             DefinitionItem = definitionItem;
-            Margin = margin;
         }
 
-        public static TargetMenuItemViewModel Create(InheritanceTargetItem target, bool indent)
+        public static TargetMenuItemViewModel Create(InheritanceTargetItem target)
         {
             var displayContent = target.DisplayName;
             var imageMoniker = target.Glyph.GetImageMoniker();
@@ -61,8 +37,7 @@ public static TargetMenuItemViewModel Create(InheritanceTargetItem target, bool
                 displayContent,
                 imageMoniker,
                 displayContent,
-                target.DefinitionItem,
-                indent ? s_indentMargin : s_defaultMargin);
+                target.DefinitionItem);
         }
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageClient/VisualStudioInProcLanguageServer.cs b/src/VisualStudio/Core/Def/Implementation/LanguageClient/VisualStudioInProcLanguageServer.cs
index ea964c8b3a819..522f8835ee73b 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageClient/VisualStudioInProcLanguageServer.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageClient/VisualStudioInProcLanguageServer.cs
@@ -204,7 +204,7 @@ private void DiagnosticService_DiagnosticsUpdated(Solution? solution, DocumentId
             => Uri.Compare(uri1, uri2, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase));
 
         // internal for testing purposes
-        internal async Task ProcessDiagnosticUpdatedBatchAsync(
+        internal async ValueTask ProcessDiagnosticUpdatedBatchAsync(
             IDiagnosticService? diagnosticService, ImmutableArray<DocumentId> documentIds, CancellationToken cancellationToken)
         {
             if (diagnosticService == null)
diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.VsCodeWindowManager.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.VsCodeWindowManager.cs
index 8254d8556ad95..accf5a857fbf3 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.VsCodeWindowManager.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.VsCodeWindowManager.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
@@ -31,7 +32,7 @@ internal class VsCodeWindowManager : IVsCodeWindowManager, IVsCodeWindowEvents
             private readonly IThreadingContext _threadingContext;
             private readonly IAsynchronousOperationListener _asynchronousOperationListener;
 
-            private INavigationBarController? _navigationBarController;
+            private IDisposable? _navigationBarController;
             private IVsDropdownBarClient? _dropdownBarClient;
             private IOptionService? _optionService;
             private WorkspaceRegistration? _workspaceRegistration;
@@ -73,8 +74,6 @@ private async Task UpdateWorkspaceAsync()
                 // There's a new workspace, so make sure we unsubscribe from the old workspace option changes and subscribe to new.
                 UpdateOptionChangedSource(_workspaceRegistration.Workspace);
 
-                _navigationBarController?.SetWorkspace(_workspaceRegistration.Workspace);
-
                 // Trigger a check to see if the dropdown should be added / removed now that the buffer is in a different workspace.
                 AddOrRemoveDropdown();
             }
@@ -209,12 +208,11 @@ private void AdddropdownBar(IVsDropdownBarManager dropdownManager)
                 var textBuffer = _languageService.EditorAdaptersFactoryService.GetDataBuffer(buffer);
                 var controllerFactoryService = _languageService.Package.ComponentModel.GetService<INavigationBarControllerFactoryService>();
                 var newController = controllerFactoryService.CreateController(navigationBarClient, textBuffer);
-                newController.SetWorkspace(_workspaceRegistration?.Workspace);
                 var hr = dropdownManager.AddDropdownBar(cCombos: 3, pClient: navigationBarClient);
 
                 if (ErrorHandler.Failed(hr))
                 {
-                    newController.Disconnect();
+                    newController.Dispose();
                     ErrorHandler.ThrowOnFailure(hr);
                 }
 
@@ -229,7 +227,7 @@ private void RemoveDropdownBar(IVsDropdownBarManager dropdownManager)
                 {
                     if (_navigationBarController != null)
                     {
-                        _navigationBarController.Disconnect();
+                        _navigationBarController.Dispose();
                         _navigationBarController = null;
                     }
 
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphBuilder.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphBuilder.cs
index 4a036f367df50..ac4ccc94536f2 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphBuilder.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphBuilder.cs
@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.Elfie.Model;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.NavigateTo;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.GraphModel;
@@ -33,8 +34,6 @@ internal sealed partial class GraphBuilder
         private readonly ISet<GraphNode> _createdNodes = new HashSet<GraphNode>();
         private readonly IList<Tuple<GraphNode, GraphProperty, object>> _deferredPropertySets = new List<Tuple<GraphNode, GraphProperty, object>>();
 
-        private readonly CancellationToken _cancellationToken;
-
         private readonly Dictionary<GraphNode, Project> _nodeToContextProjectMap = new();
         private readonly Dictionary<GraphNode, Document> _nodeToContextDocumentMap = new();
         private readonly Dictionary<GraphNode, ISymbol> _nodeToSymbolMap = new();
@@ -44,34 +43,34 @@ internal sealed partial class GraphBuilder
         /// </summary>
         private readonly Solution _solution;
 
-        public GraphBuilder(Solution solution, CancellationToken cancellationToken)
+        public GraphBuilder(Solution solution)
         {
             _solution = solution;
-            _cancellationToken = cancellationToken;
         }
 
-        public static async Task<GraphBuilder> CreateForInputNodesAsync(Solution solution, IEnumerable<GraphNode> inputNodes, CancellationToken cancellationToken)
+        public static async Task<GraphBuilder> CreateForInputNodesAsync(
+            Solution solution, IEnumerable<GraphNode> inputNodes, CancellationToken cancellationToken)
         {
-            var builder = new GraphBuilder(solution, cancellationToken);
+            var builder = new GraphBuilder(solution);
 
             foreach (var inputNode in inputNodes)
             {
                 if (inputNode.HasCategory(CodeNodeCategories.File))
                 {
-                    builder.PopulateMapsForFileInputNode(inputNode);
+                    builder.PopulateMapsForFileInputNode(inputNode, cancellationToken);
                 }
                 else if (!inputNode.HasCategory(CodeNodeCategories.SourceLocation))
                 {
-                    await builder.PopulateMapsForSymbolInputNodeAsync(inputNode).ConfigureAwait(false);
+                    await builder.PopulateMapsForSymbolInputNodeAsync(inputNode, cancellationToken).ConfigureAwait(false);
                 }
             }
 
             return builder;
         }
 
-        private void PopulateMapsForFileInputNode(GraphNode inputNode)
+        private void PopulateMapsForFileInputNode(GraphNode inputNode, CancellationToken cancellationToken)
         {
-            using (_gate.DisposableWait())
+            using (_gate.DisposableWait(cancellationToken))
             {
                 var projectPath = inputNode.Id.GetNestedValueByName<Uri>(CodeGraphNodeIdName.Assembly);
                 var filePath = inputNode.Id.GetNestedValueByName<Uri>(CodeGraphNodeIdName.File);
@@ -101,9 +100,9 @@ private void PopulateMapsForFileInputNode(GraphNode inputNode)
             }
         }
 
-        private async Task PopulateMapsForSymbolInputNodeAsync(GraphNode inputNode)
+        private async Task PopulateMapsForSymbolInputNodeAsync(GraphNode inputNode, CancellationToken cancellationToken)
         {
-            using (await _gate.DisposableWaitAsync(_cancellationToken).ConfigureAwait(false))
+            using (await _gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
             {
                 var projectId = (ProjectId)inputNode[RoslynGraphProperties.ContextProjectId];
                 if (projectId == null)
@@ -119,9 +118,9 @@ private async Task PopulateMapsForSymbolInputNodeAsync(GraphNode inputNode)
 
                 _nodeToContextProjectMap.Add(inputNode, project);
 
-                var compilation = await project.GetCompilationAsync(_cancellationToken).ConfigureAwait(false);
+                var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
                 var symbolId = (SymbolKey?)inputNode[RoslynGraphProperties.SymbolId];
-                var symbol = symbolId.Value.Resolve(compilation).Symbol;
+                var symbol = symbolId.Value.Resolve(compilation, cancellationToken: cancellationToken).Symbol;
                 if (symbol != null)
                 {
                     _nodeToSymbolMap.Add(inputNode, symbol);
@@ -139,9 +138,9 @@ private async Task PopulateMapsForSymbolInputNodeAsync(GraphNode inputNode)
             }
         }
 
-        public Project GetContextProject(GraphNode node)
+        public Project GetContextProject(GraphNode node, CancellationToken cancellationToken)
         {
-            using (_gate.DisposableWait())
+            using (_gate.DisposableWait(cancellationToken))
             {
                 _nodeToContextProjectMap.TryGetValue(node, out var project);
                 return project;
@@ -154,32 +153,37 @@ public ProjectId GetContextProjectId(Project project, ISymbol symbol)
             return thisProject.Id;
         }
 
-        public Document GetContextDocument(GraphNode node)
+        public Document GetContextDocument(GraphNode node, CancellationToken cancellationToken)
         {
-            using (_gate.DisposableWait())
+            using (_gate.DisposableWait(cancellationToken))
             {
                 _nodeToContextDocumentMap.TryGetValue(node, out var document);
                 return document;
             }
         }
 
-        public ISymbol GetSymbol(GraphNode node)
+        public ISymbol GetSymbol(GraphNode node, CancellationToken cancellationToken)
         {
-            using (_gate.DisposableWait())
+            using (_gate.DisposableWait(cancellationToken))
             {
                 _nodeToSymbolMap.TryGetValue(node, out var symbol);
                 return symbol;
             }
         }
 
-        public Task<GraphNode> AddNodeAsync(ISymbol symbol, GraphNode relatedNode)
+        public Task<GraphNode> AddNodeAsync(ISymbol symbol, GraphNode relatedNode, CancellationToken cancellationToken)
         {
             // The lack of a lock here is acceptable, since each of the functions lock, and GetContextProject/GetContextDocument
             // never change for the same input.
-            return AddNodeAsync(symbol, GetContextProject(relatedNode), GetContextDocument(relatedNode));
+            return AddNodeAsync(
+                symbol,
+                GetContextProject(relatedNode, cancellationToken),
+                GetContextDocument(relatedNode, cancellationToken),
+                cancellationToken);
         }
 
-        public async Task<GraphNode> AddNodeAsync(ISymbol symbol, Project contextProject, Document contextDocument)
+        public async Task<GraphNode> AddNodeAsync(
+            ISymbol symbol, Project contextProject, Document contextDocument, CancellationToken cancellationToken)
         {
             // Figure out what the location for this node should be. We'll arbitrarily pick the
             // first one, unless we have a contextDocument to restrict it
@@ -187,7 +191,7 @@ public async Task<GraphNode> AddNodeAsync(ISymbol symbol, Project contextProject
 
             if (contextDocument != null)
             {
-                var syntaxTree = await contextDocument.GetSyntaxTreeAsync(_cancellationToken).ConfigureAwait(false);
+                var syntaxTree = await contextDocument.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
 
                 // If we have one in that tree, use it
                 preferredLocation = symbol.Locations.FirstOrDefault(l => l.SourceTree == syntaxTree) ?? preferredLocation;
@@ -196,18 +200,18 @@ public async Task<GraphNode> AddNodeAsync(ISymbol symbol, Project contextProject
             // We may need to look up source code within this solution
             if (preferredLocation == null && symbol.Locations.Any(loc => loc.IsInMetadata))
             {
-                var newSymbol = await SymbolFinder.FindSourceDefinitionAsync(symbol, contextProject.Solution, _cancellationToken).ConfigureAwait(false);
+                var newSymbol = await SymbolFinder.FindSourceDefinitionAsync(symbol, contextProject.Solution, cancellationToken).ConfigureAwait(false);
                 if (newSymbol != null)
                 {
                     preferredLocation = newSymbol.Locations.Where(loc => loc.IsInSource).FirstOrDefault();
                 }
             }
 
-            using (_gate.DisposableWait())
+            using (_gate.DisposableWait(cancellationToken))
             {
-                var node = await GetOrCreateNodeAsync(_graph, symbol, _solution, _cancellationToken).ConfigureAwait(false);
+                var node = await GetOrCreateNodeAsync(_graph, symbol, _solution, cancellationToken).ConfigureAwait(false);
 
-                node[RoslynGraphProperties.SymbolId] = (SymbolKey?)symbol.GetSymbolKey();
+                node[RoslynGraphProperties.SymbolId] = (SymbolKey?)symbol.GetSymbolKey(cancellationToken);
                 node[RoslynGraphProperties.ContextProjectId] = GetContextProjectId(contextProject, symbol);
                 node[RoslynGraphProperties.ExplicitInterfaceImplementations] = symbol.ExplicitInterfaceImplementations().Select(s => s.GetSymbolKey()).ToList();
                 node[RoslynGraphProperties.DeclaredAccessibility] = symbol.DeclaredAccessibility;
@@ -665,17 +669,17 @@ private static async Task<GraphNode> GetOrCreateNodeForEventAsync(Graph graph, I
             return node;
         }
 
-        public void AddLink(GraphNode from, GraphCategory category, GraphNode to)
+        public void AddLink(GraphNode from, GraphCategory category, GraphNode to, CancellationToken cancellationToken)
         {
-            using (_gate.DisposableWait())
+            using (_gate.DisposableWait(cancellationToken))
             {
                 _graph.Links.GetOrCreate(from, to).AddCategory(category);
             }
         }
 
-        public GraphNode AddNodeForDocument(Document document)
+        public GraphNode AddNodeForDocument(Document document, CancellationToken cancellationToken)
         {
-            using (_gate.DisposableWait())
+            using (_gate.DisposableWait(cancellationToken))
             {
                 var id = GraphNodeIdCreation.GetIdForDocument(document);
 
@@ -690,9 +694,101 @@ public GraphNode AddNodeForDocument(Document document)
             }
         }
 
-        public void ApplyToGraph(Graph graph)
+        public async Task<GraphNode> CreateNodeAsync(INavigateToSearchResult result, CancellationToken cancellationToken)
         {
-            using (_gate.DisposableWait())
+            var document = result.NavigableItem.Document;
+            var project = document.Project;
+
+            // If it doesn't belong to a document or project we can navigate to, then ignore entirely.
+            if (document.FilePath == null || project.FilePath == null)
+                return null;
+
+            var category = result.Kind switch
+            {
+                NavigateToItemKind.Class => CodeNodeCategories.Class,
+                NavigateToItemKind.Delegate => CodeNodeCategories.Delegate,
+                NavigateToItemKind.Enum => CodeNodeCategories.Enum,
+                NavigateToItemKind.Interface => CodeNodeCategories.Interface,
+                NavigateToItemKind.Module => CodeNodeCategories.Module,
+                NavigateToItemKind.Structure => CodeNodeCategories.Struct,
+                NavigateToItemKind.Method => CodeNodeCategories.Method,
+                NavigateToItemKind.Property => CodeNodeCategories.Property,
+                NavigateToItemKind.Event => CodeNodeCategories.Event,
+                NavigateToItemKind.Constant or
+                NavigateToItemKind.EnumItem or
+                NavigateToItemKind.Field => CodeNodeCategories.Field,
+                _ => null,
+            };
+
+            // If it's not a category that progression understands, then ignore.
+            if (category == null)
+                return null;
+
+            // Get or make a node for this symbol's containing document that will act as the parent node in the UI.
+            var documentNode = this.AddNodeForDocument(document, cancellationToken);
+
+            // For purposes of keying this node, just use the display text we will show.  In practice, outside of error
+            // scenarios this will be unique and suitable as an ID (esp. as these names are joined with their parent
+            // document name to form the full ID).
+            var label = result.NavigableItem.DisplayTaggedParts.JoinText();
+            var id = documentNode.Id.Add(GraphNodeId.GetLiteral(label));
+
+            // If we already have a node that matches this (say there are multiple identical sibling symbols in an error
+            // situation).  We just ignore the second match.
+            var existing = _graph.Nodes.Get(id);
+            if (existing != null)
+                return null;
+
+            var symbolNode = _graph.Nodes.GetOrCreate(id);
+
+            symbolNode.Label = label;
+            symbolNode.AddCategory(category);
+            symbolNode[DgmlNodeProperties.Icon] = GetIconString(result.NavigableItem.Glyph);
+            symbolNode[RoslynGraphProperties.ContextDocumentId] = document.Id;
+            symbolNode[RoslynGraphProperties.ContextProjectId] = project.Id;
+
+            var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            var span = text.Lines.GetLinePositionSpan(NavigateToUtilities.GetBoundedSpan(result.NavigableItem, text));
+
+            symbolNode[CodeNodeProperties.SourceLocation] = new SourceLocation(
+                document.FilePath,
+                new Position(span.Start.Line, span.Start.Character),
+                new Position(span.End.Line, span.End.Character));
+
+            this.AddLink(documentNode, GraphCommonSchema.Contains, symbolNode, cancellationToken);
+
+            return symbolNode;
+        }
+
+        private static string GetIconString(Glyph glyph)
+        {
+            var groupName = glyph switch
+            {
+                Glyph.ClassPublic or Glyph.ClassProtected or Glyph.ClassPrivate or Glyph.ClassInternal => "Class",
+                Glyph.ConstantPublic or Glyph.ConstantProtected or Glyph.ConstantPrivate or Glyph.ConstantInternal => "Field",
+                Glyph.DelegatePublic or Glyph.DelegateProtected or Glyph.DelegatePrivate or Glyph.DelegateInternal => "Delegate",
+                Glyph.EnumPublic or Glyph.EnumProtected or Glyph.EnumPrivate or Glyph.EnumInternal => "Enum",
+                Glyph.EnumMemberPublic or Glyph.EnumMemberProtected or Glyph.EnumMemberPrivate or Glyph.EnumMemberInternal => "EnumMember",
+                Glyph.ExtensionMethodPublic or Glyph.ExtensionMethodProtected or Glyph.ExtensionMethodPrivate or Glyph.ExtensionMethodInternal => "Method",
+                Glyph.EventPublic or Glyph.EventProtected or Glyph.EventPrivate or Glyph.EventInternal => "Event",
+                Glyph.FieldPublic or Glyph.FieldProtected or Glyph.FieldPrivate or Glyph.FieldInternal => "Field",
+                Glyph.InterfacePublic or Glyph.InterfaceProtected or Glyph.InterfacePrivate or Glyph.InterfaceInternal => "Interface",
+                Glyph.MethodPublic or Glyph.MethodProtected or Glyph.MethodPrivate or Glyph.MethodInternal => "Method",
+                Glyph.ModulePublic or Glyph.ModuleProtected or Glyph.ModulePrivate or Glyph.ModuleInternal => "Module",
+                Glyph.PropertyPublic or Glyph.PropertyProtected or Glyph.PropertyPrivate or Glyph.PropertyInternal => "Property",
+                Glyph.StructurePublic or Glyph.StructureProtected or Glyph.StructurePrivate or Glyph.StructureInternal => "Structure",
+                _ => null,
+            };
+
+            if (groupName == null)
+                return null;
+
+            return IconHelper.GetIconName(groupName, GlyphExtensions.GetAccessibility(GlyphTags.GetTags(glyph)));
+        }
+
+        public void ApplyToGraph(Graph graph, CancellationToken cancellationToken)
+        {
+            using (_gate.DisposableWait(cancellationToken))
             {
                 using var graphTransaction = new GraphTransactionScope();
                 graph.Merge(this.Graph);
@@ -707,9 +803,9 @@ public void ApplyToGraph(Graph graph)
             }
         }
 
-        public void AddDeferredPropertySet(GraphNode node, GraphProperty property, object value)
+        public void AddDeferredPropertySet(GraphNode node, GraphProperty property, object value, CancellationToken cancellationToken)
         {
-            using (_gate.DisposableWait())
+            using (_gate.DisposableWait(cancellationToken))
             {
                 _deferredPropertySets.Add(Tuple.Create(node, property, value));
             }
@@ -723,25 +819,11 @@ public Graph Graph
             }
         }
 
-        public IEnumerable<GraphNode> CreatedNodes
-        {
-            get
-            {
-                using (_gate.DisposableWait())
-                {
-                    return _createdNodes.ToArray();
-                }
-            }
-        }
-
-        public IEnumerable<Tuple<GraphNode, GraphProperty, object>> DeferredPropertySets
+        public IEnumerable<GraphNode> GetCreatedNodes(CancellationToken cancellationToken)
         {
-            get
+            using (_gate.DisposableWait(cancellationToken))
             {
-                using (_gate.DisposableWait())
-                {
-                    return _deferredPropertySets.ToArray();
-                }
+                return _createdNodes.ToArray();
             }
         }
     }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphProvider.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphProvider.cs
index 9ff632119c43f..616538256944c 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphProvider.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphProvider.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.GraphModel;
+using Microsoft.VisualStudio.GraphModel.CodeSchema;
 using Microsoft.VisualStudio.GraphModel.Schemas;
 using Microsoft.VisualStudio.Language.Intellisense;
 using Microsoft.VisualStudio.Progression;
@@ -25,6 +26,7 @@ internal class AbstractGraphProvider : IGraphProvider
         private readonly IThreadingContext _threadingContext;
         private readonly IGlyphService _glyphService;
         private readonly IServiceProvider _serviceProvider;
+        private readonly IAsynchronousOperationListener _asyncListener;
         private readonly Workspace _workspace;
         private readonly GraphQueryManager _graphQueryManager;
 
@@ -40,9 +42,9 @@ protected AbstractGraphProvider(
             _threadingContext = threadingContext;
             _glyphService = glyphService;
             _serviceProvider = serviceProvider;
-            var asyncListener = listenerProvider.GetListener(FeatureAttribute.GraphProvider);
+            _asyncListener = listenerProvider.GetListener(FeatureAttribute.GraphProvider);
             _workspace = workspace;
-            _graphQueryManager = new GraphQueryManager(workspace, asyncListener);
+            _graphQueryManager = new GraphQueryManager(workspace, _asyncListener);
         }
 
         private void EnsureInitialized()
@@ -57,7 +59,10 @@ private void EnsureInitialized()
             _initialized = true;
         }
 
-        internal static List<IGraphQuery> GetGraphQueries(IGraphContext context)
+        internal static List<IGraphQuery> GetGraphQueries(
+            IGraphContext context,
+            IThreadingContext threadingContext,
+            IAsynchronousOperationListener asyncListener)
         {
             var graphQueries = new List<IGraphQuery>();
 
@@ -134,7 +139,8 @@ internal static List<IGraphQuery> GetGraphQueries(IGraphContext context)
                     // WARNING: searchParameters.SearchQuery returns an IVsSearchQuery object, which
                     // is a COM type. Therefore, it's probably best to grab the values we want now
                     // rather than get surprised by COM marshalling later.
-                    graphQueries.Add(new SearchGraphQuery(searchParameters.SearchQuery.SearchString));
+                    graphQueries.Add(new SearchGraphQuery(
+                        searchParameters.SearchQuery.SearchString, threadingContext, asyncListener));
                 }
             }
 
@@ -145,7 +151,7 @@ public void BeginGetGraphData(IGraphContext context)
         {
             EnsureInitialized();
 
-            var graphQueries = GetGraphQueries(context);
+            var graphQueries = GetGraphQueries(context, _threadingContext, _asyncListener);
 
             if (graphQueries.Count > 0)
             {
@@ -345,23 +351,21 @@ public T GetExtension<T>(GraphObject graphObject, T previous) where T : class
             if (graphObject is GraphNode graphNode)
             {
                 // If this is not a Roslyn node, bail out.
-                // TODO: The check here is to see if the SymbolId property exists on the node
-                // and if so, that's been created by us. However, eventually we'll want to extend
-                // this to other scenarios where C#\VB nodes that aren't created by us are passed in.
-                if (graphNode.GetValue<SymbolKey?>(RoslynGraphProperties.SymbolId) == null)
+                if (graphNode.GetValue(RoslynGraphProperties.ContextProjectId) == null)
+                    return null;
+
+                // Has to have at least a symbolid, or source location to navigate to.
+                if (graphNode.GetValue<SymbolKey?>(RoslynGraphProperties.SymbolId) == null &&
+                    graphNode.GetValue<SourceLocation>(CodeNodeProperties.SourceLocation).FileName == null)
                 {
                     return null;
                 }
 
                 if (typeof(T) == typeof(IGraphNavigateToItem))
-                {
                     return new GraphNavigatorExtension(_threadingContext, _workspace) as T;
-                }
 
                 if (typeof(T) == typeof(IGraphFormattedLabel))
-                {
                     return new GraphFormattedLabelExtension() as T;
-                }
             }
 
             return null;
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/CallsGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/CallsGraphQuery.cs
index e6d033200b98d..e88829a5de308 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/CallsGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/CallsGraphQuery.cs
@@ -23,15 +23,15 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
 
             foreach (var node in context.InputNodes)
             {
-                var symbol = graphBuilder.GetSymbol(node);
+                var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                 if (symbol != null)
                 {
                     foreach (var newSymbol in await GetCalledMethodSymbolsAsync(symbol, solution, cancellationToken).ConfigureAwait(false))
                     {
                         cancellationToken.ThrowIfCancellationRequested();
 
-                        var newNode = await graphBuilder.AddNodeAsync(newSymbol, relatedNode: node).ConfigureAwait(false);
-                        graphBuilder.AddLink(node, CodeLinkCategories.Calls, newNode);
+                        var newNode = await graphBuilder.AddNodeAsync(newSymbol, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                        graphBuilder.AddLink(node, CodeLinkCategories.Calls, newNode, cancellationToken);
                     }
                 }
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ContainsChildrenGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ContainsChildrenGraphQuery.cs
index 23a5071dbbf5d..e5a95567036e8 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ContainsChildrenGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ContainsChildrenGraphQuery.cs
@@ -25,21 +25,21 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
             {
                 if (!cancellationToken.IsCancellationRequested)
                 {
-                    var symbol = graphBuilder.GetSymbol(node);
-
+                    var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                     if (symbol != null)
                     {
                         var containsChildren = SymbolContainment.GetContainedSymbols(symbol).Any();
-                        graphBuilder.AddDeferredPropertySet(node, DgmlNodeProperties.ContainsChildren, containsChildren);
+                        graphBuilder.AddDeferredPropertySet(
+                            node, DgmlNodeProperties.ContainsChildren, containsChildren, cancellationToken);
                     }
                     else if (node.HasCategory(CodeNodeCategories.File))
                     {
-                        var document = graphBuilder.GetContextDocument(node);
-
+                        var document = graphBuilder.GetContextDocument(node, cancellationToken);
                         if (document != null)
                         {
                             var childNodes = await SymbolContainment.GetContainedSyntaxNodesAsync(document, cancellationToken).ConfigureAwait(false);
-                            graphBuilder.AddDeferredPropertySet(node, DgmlNodeProperties.ContainsChildren, childNodes.Any());
+                            graphBuilder.AddDeferredPropertySet(
+                                node, DgmlNodeProperties.ContainsChildren, childNodes.Any(), cancellationToken);
                         }
                         else
                         {
@@ -72,7 +72,8 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
                                 // also perform the check.
                                 if (path.EndsWith(".cs", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".vb", StringComparison.OrdinalIgnoreCase))
                                 {
-                                    graphBuilder.AddDeferredPropertySet(node, DgmlNodeProperties.ContainsChildren, false);
+                                    graphBuilder.AddDeferredPropertySet(
+                                        node, DgmlNodeProperties.ContainsChildren, value: false, cancellationToken);
                                 }
                             }
                         }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ContainsGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ContainsGraphQuery.cs
index 9ae7defcd84e2..eb9ad620eecca 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ContainsGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ContainsGraphQuery.cs
@@ -33,30 +33,30 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
                 {
                     cancellationToken.ThrowIfCancellationRequested();
 
-                    var symbol = graphBuilder.GetSymbol(node);
-
+                    var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                     if (symbol != null)
                     {
                         foreach (var newSymbol in SymbolContainment.GetContainedSymbols(symbol))
                         {
                             cancellationToken.ThrowIfCancellationRequested();
 
-                            var newNode = await graphBuilder.AddNodeAsync(newSymbol, relatedNode: node).ConfigureAwait(false);
-                            graphBuilder.AddLink(node, GraphCommonSchema.Contains, newNode);
+                            var newNode = await graphBuilder.AddNodeAsync(
+                                newSymbol, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                            graphBuilder.AddLink(node, GraphCommonSchema.Contains, newNode, cancellationToken);
                         }
                     }
                     else if (node.HasCategory(CodeNodeCategories.File))
                     {
-                        var document = graphBuilder.GetContextDocument(node);
-
+                        var document = graphBuilder.GetContextDocument(node, cancellationToken);
                         if (document != null)
                         {
                             foreach (var newSymbol in await SymbolContainment.GetContainedSymbolsAsync(document, cancellationToken).ConfigureAwait(false))
                             {
                                 cancellationToken.ThrowIfCancellationRequested();
 
-                                var newNode = await graphBuilder.AddNodeAsync(newSymbol, relatedNode: node).ConfigureAwait(false);
-                                graphBuilder.AddLink(node, GraphCommonSchema.Contains, newNode);
+                                var newNode = await graphBuilder.AddNodeAsync(
+                                    newSymbol, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                                graphBuilder.AddLink(node, GraphCommonSchema.Contains, newNode, cancellationToken);
                             }
                         }
                     }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ImplementedByGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ImplementedByGraphQuery.cs
index 27fa385ab03f9..1e022e65eedf0 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ImplementedByGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ImplementedByGraphQuery.cs
@@ -24,7 +24,7 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
 
                 foreach (var node in context.InputNodes)
                 {
-                    var symbol = graphBuilder.GetSymbol(node);
+                    var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                     if (symbol is INamedTypeSymbol ||
                         symbol is IMethodSymbol ||
                         symbol is IPropertySymbol ||
@@ -34,8 +34,10 @@ symbol is IPropertySymbol ||
 
                         foreach (var implementation in implementations)
                         {
-                            var symbolNode = await graphBuilder.AddNodeAsync(implementation, relatedNode: node).ConfigureAwait(false);
-                            graphBuilder.AddLink(symbolNode, CodeLinkCategories.Implements, node);
+                            var symbolNode = await graphBuilder.AddNodeAsync(
+                                implementation, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                            graphBuilder.AddLink(
+                                symbolNode, CodeLinkCategories.Implements, node, cancellationToken);
                         }
                     }
                 }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ImplementsGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ImplementsGraphQuery.cs
index 4c32c1ea06332..6866d33bc520d 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ImplementsGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ImplementsGraphQuery.cs
@@ -26,19 +26,19 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
 
                 foreach (var node in context.InputNodes)
                 {
-                    var symbol = graphBuilder.GetSymbol(node);
+                    var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                     if (symbol is INamedTypeSymbol namedType)
                     {
                         var implementedSymbols = ImmutableArray<ISymbol>.CastUp(namedType.AllInterfaces);
 
-                        await AddImplementedSymbolsAsync(graphBuilder, node, implementedSymbols).ConfigureAwait(false);
+                        await AddImplementedSymbolsAsync(graphBuilder, node, implementedSymbols, cancellationToken).ConfigureAwait(false);
                     }
                     else if (symbol is IMethodSymbol ||
                              symbol is IPropertySymbol ||
                              symbol is IEventSymbol)
                     {
                         var implements = await SymbolFinder.FindImplementedInterfaceMembersArrayAsync(symbol, solution, cancellationToken: cancellationToken).ConfigureAwait(false);
-                        await AddImplementedSymbolsAsync(graphBuilder, node, implements).ConfigureAwait(false);
+                        await AddImplementedSymbolsAsync(graphBuilder, node, implements, cancellationToken).ConfigureAwait(false);
                     }
                 }
 
@@ -47,13 +47,13 @@ symbol is IPropertySymbol ||
         }
 
         private static async Task AddImplementedSymbolsAsync(
-            GraphBuilder graphBuilder, GraphNode node,
-            ImmutableArray<ISymbol> implementedSymbols)
+            GraphBuilder graphBuilder, GraphNode node, ImmutableArray<ISymbol> implementedSymbols, CancellationToken cancellationToken)
         {
             foreach (var interfaceType in implementedSymbols)
             {
-                var interfaceTypeNode = await graphBuilder.AddNodeAsync(interfaceType, relatedNode: node).ConfigureAwait(false);
-                graphBuilder.AddLink(node, CodeLinkCategories.Implements, interfaceTypeNode);
+                var interfaceTypeNode = await graphBuilder.AddNodeAsync(
+                    interfaceType, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                graphBuilder.AddLink(node, CodeLinkCategories.Implements, interfaceTypeNode, cancellationToken);
             }
         }
     }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/InheritedByGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/InheritedByGraphQuery.cs
index a2a326243e3fa..cf991313e399d 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/InheritedByGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/InheritedByGraphQuery.cs
@@ -22,7 +22,7 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
 
             foreach (var node in context.InputNodes)
             {
-                var symbol = graphBuilder.GetSymbol(node);
+                var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                 if (!(symbol is INamedTypeSymbol namedType))
                     continue;
 
@@ -33,8 +33,8 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
                     foreach (var derivedType in derivedTypes)
                     {
                         var symbolNode = await graphBuilder.AddNodeAsync(
-                            derivedType, relatedNode: node).ConfigureAwait(false);
-                        graphBuilder.AddLink(symbolNode, CodeLinkCategories.InheritsFrom, node);
+                            derivedType, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                        graphBuilder.AddLink(symbolNode, CodeLinkCategories.InheritsFrom, node, cancellationToken);
                     }
                 }
                 else if (namedType.TypeKind == TypeKind.Interface)
@@ -46,8 +46,8 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
                     foreach (var derivedType in implementingClassesAndStructs.Concat(derivedInterfaces))
                     {
                         var symbolNode = await graphBuilder.AddNodeAsync(
-                            derivedType, relatedNode: node).ConfigureAwait(false);
-                        graphBuilder.AddLink(symbolNode, CodeLinkCategories.InheritsFrom, node);
+                            derivedType, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                        graphBuilder.AddLink(symbolNode, CodeLinkCategories.InheritsFrom, node, cancellationToken);
                     }
                 }
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/InheritsGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/InheritsGraphQuery.cs
index 31488b032efa6..6845b7171d254 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/InheritsGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/InheritsGraphQuery.cs
@@ -33,24 +33,24 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
 
                 foreach (var node in nodesToProcess)
                 {
-                    var symbol = graphBuilder.GetSymbol(node);
+                    var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                     if (symbol is INamedTypeSymbol namedType)
                     {
                         if (namedType.BaseType != null)
                         {
                             var baseTypeNode = await graphBuilder.AddNodeAsync(
-                                namedType.BaseType, relatedNode: node).ConfigureAwait(false);
+                                namedType.BaseType, relatedNode: node, cancellationToken).ConfigureAwait(false);
                             newNodes.Add(baseTypeNode);
-                            graphBuilder.AddLink(node, CodeLinkCategories.InheritsFrom, baseTypeNode);
+                            graphBuilder.AddLink(node, CodeLinkCategories.InheritsFrom, baseTypeNode, cancellationToken);
                         }
                         else if (namedType.TypeKind == TypeKind.Interface && !namedType.OriginalDefinition.AllInterfaces.IsEmpty)
                         {
                             foreach (var baseNode in namedType.OriginalDefinition.AllInterfaces.Distinct())
                             {
                                 var baseTypeNode = await graphBuilder.AddNodeAsync(
-                                    baseNode, relatedNode: node).ConfigureAwait(false);
+                                    baseNode, relatedNode: node, cancellationToken).ConfigureAwait(false);
                                 newNodes.Add(baseTypeNode);
-                                graphBuilder.AddLink(node, CodeLinkCategories.InheritsFrom, baseTypeNode);
+                                graphBuilder.AddLink(node, CodeLinkCategories.InheritsFrom, baseTypeNode, cancellationToken);
                             }
                         }
                     }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/IsCalledByGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/IsCalledByGraphQuery.cs
index bff167a6f4b28..d5198f76bd6ba 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/IsCalledByGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/IsCalledByGraphQuery.cs
@@ -25,15 +25,16 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
 
                 foreach (var node in context.InputNodes)
                 {
-                    var symbol = graphBuilder.GetSymbol(node);
+                    var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                     if (symbol != null)
                     {
                         var callers = await SymbolFinder.FindCallersAsync(symbol, solution, cancellationToken).ConfigureAwait(false);
 
                         foreach (var caller in callers.Where(c => c.IsDirect))
                         {
-                            var callerNode = await graphBuilder.AddNodeAsync(caller.CallingSymbol, relatedNode: node).ConfigureAwait(false);
-                            graphBuilder.AddLink(callerNode, CodeLinkCategories.Calls, node);
+                            var callerNode = await graphBuilder.AddNodeAsync(
+                                caller.CallingSymbol, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                            graphBuilder.AddLink(callerNode, CodeLinkCategories.Calls, node, cancellationToken);
                         }
                     }
                 }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/IsUsedByGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/IsUsedByGraphQuery.cs
index 99495e398949b..f9ad48d359da4 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/IsUsedByGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/IsUsedByGraphQuery.cs
@@ -26,13 +26,13 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
 
                 foreach (var node in context.InputNodes)
                 {
-                    var symbol = graphBuilder.GetSymbol(node);
+                    var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                     var references = await SymbolFinder.FindReferencesAsync(symbol, solution, cancellationToken).ConfigureAwait(false);
 
                     foreach (var reference in references)
                     {
                         var referencedSymbol = reference.Definition;
-                        var projectId = graphBuilder.GetContextProject(node).Id;
+                        var projectId = graphBuilder.GetContextProject(node, cancellationToken).Id;
 
                         var allLocations = referencedSymbol.Locations.Concat(reference.Locations.Select(r => r.Location))
                                                                      .Where(l => l != null && l.IsInSource);
@@ -40,7 +40,7 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
                         foreach (var location in allLocations)
                         {
                             var locationNode = GetLocationNode(location, context, projectId, cancellationToken);
-                            graphBuilder.AddLink(node, CodeLinkCategories.SourceReferences, locationNode);
+                            graphBuilder.AddLink(node, CodeLinkCategories.SourceReferences, locationNode, cancellationToken);
                         }
                     }
                 }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/OverriddenByGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/OverriddenByGraphQuery.cs
index 980a3b701d722..a549654ec973a 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/OverriddenByGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/OverriddenByGraphQuery.cs
@@ -21,15 +21,15 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
 
             foreach (var node in context.InputNodes)
             {
-                var symbol = graphBuilder.GetSymbol(node);
+                var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                 if (symbol != null)
                 {
                     var overriddenMember = symbol.GetOverriddenMember();
                     if (overriddenMember != null)
                     {
                         var symbolNode = await graphBuilder.AddNodeAsync(
-                            overriddenMember, relatedNode: node).ConfigureAwait(false);
-                        graphBuilder.AddLink(node, RoslynGraphCategories.Overrides, symbolNode);
+                            overriddenMember, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                        graphBuilder.AddLink(node, RoslynGraphCategories.Overrides, symbolNode, cancellationToken);
                     }
                 }
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/OverridesGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/OverridesGraphQuery.cs
index dd397440df7f6..e87423e4c3a0f 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/OverridesGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/OverridesGraphQuery.cs
@@ -23,7 +23,7 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
 
                 foreach (var node in context.InputNodes)
                 {
-                    var symbol = graphBuilder.GetSymbol(node);
+                    var symbol = graphBuilder.GetSymbol(node, cancellationToken);
                     if (symbol is IMethodSymbol ||
                         symbol is IPropertySymbol ||
                         symbol is IEventSymbol)
@@ -31,8 +31,8 @@ symbol is IPropertySymbol ||
                         var overrides = await SymbolFinder.FindOverridesAsync(symbol, solution, cancellationToken: cancellationToken).ConfigureAwait(false);
                         foreach (var o in overrides)
                         {
-                            var symbolNode = await graphBuilder.AddNodeAsync(o, relatedNode: node).ConfigureAwait(false);
-                            graphBuilder.AddLink(symbolNode, RoslynGraphCategories.Overrides, node);
+                            var symbolNode = await graphBuilder.AddNodeAsync(o, relatedNode: node, cancellationToken).ConfigureAwait(false);
+                            graphBuilder.AddLink(symbolNode, RoslynGraphCategories.Overrides, node, cancellationToken);
                         }
                     }
                 }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ProgressionNavigateToSearchCallback.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ProgressionNavigateToSearchCallback.cs
new file mode 100644
index 0000000000000..16bdf6b527190
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/ProgressionNavigateToSearchCallback.cs
@@ -0,0 +1,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.VisualStudio.GraphModel;
+using Microsoft.CodeAnalysis.NavigateTo;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.Progression
+{
+    internal sealed partial class SearchGraphQuery
+    {
+        private class ProgressionNavigateToSearchCallback : INavigateToSearchCallback
+        {
+            private readonly IGraphContext _context;
+            private readonly GraphBuilder _graphBuilder;
+
+            public ProgressionNavigateToSearchCallback(IGraphContext context, GraphBuilder graphBuilder)
+            {
+                _context = context;
+                _graphBuilder = graphBuilder;
+            }
+
+            public void Done(bool isFullyLoaded)
+            {
+                // Do nothing here.  Even though the navigate to search completed, we still haven't passed any
+                // information along to progression.  That will happen in GraphQueryManager.PopulateContextGraphAsync
+            }
+
+            public void ReportProgress(int current, int maximum)
+                => _context.ReportProgress(current, maximum, null);
+
+            public async Task AddItemAsync(Project project, INavigateToSearchResult result, CancellationToken cancellationToken)
+            {
+                var node = await _graphBuilder.CreateNodeAsync(result, cancellationToken).ConfigureAwait(false);
+                if (node != null)
+                {
+                    // _context.OutputNodes is not threadsafe.  So ensure only one navto callback can mutate it at a time.
+                    lock (this)
+                        _context.OutputNodes.Add(node);
+                }
+            }
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/SearchGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/SearchGraphQuery.cs
index 9839277a77d9f..2a525df7db468 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/SearchGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/SearchGraphQuery.cs
@@ -2,31 +2,67 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.FindSymbols;
+using Microsoft.CodeAnalysis.NavigateTo;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.GraphModel;
 using Roslyn.Utilities;
-using System.Runtime.ExceptionServices;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Progression
 {
-    internal sealed class SearchGraphQuery : IGraphQuery
+    internal sealed partial class SearchGraphQuery : IGraphQuery
     {
+        private readonly IThreadingContext _threadingContext;
+        private readonly IAsynchronousOperationListener _asyncListener;
         private readonly string _searchPattern;
 
-        public SearchGraphQuery(string searchPattern)
-            => _searchPattern = searchPattern;
+        public SearchGraphQuery(
+            string searchPattern,
+            IThreadingContext threadingContext,
+            IAsynchronousOperationListener asyncListener)
+        {
+            _threadingContext = threadingContext;
+            _asyncListener = asyncListener;
+            _searchPattern = searchPattern;
+        }
+
+        public Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext context, CancellationToken cancellationToken)
+        {
+            var option = solution.Options.GetOption(ProgressionOptions.SearchUsingNavigateToEngine);
+            return option
+                ? SearchUsingNavigateToEngineAsync(solution, context, cancellationToken)
+                : SearchUsingSymbolsAsync(solution, context, cancellationToken);
+        }
+
+        private async Task<GraphBuilder> SearchUsingNavigateToEngineAsync(Solution solution, IGraphContext context, CancellationToken cancellationToken)
+        {
+            var graphBuilder = await GraphBuilder.CreateForInputNodesAsync(solution, context.InputNodes, cancellationToken).ConfigureAwait(false);
+            var callback = new ProgressionNavigateToSearchCallback(context, graphBuilder);
+            var searcher = NavigateToSearcher.Create(
+                solution,
+                _asyncListener,
+                callback,
+                _searchPattern,
+                searchCurrentDocument: false,
+                NavigateToUtilities.GetKindsProvided(solution),
+                _threadingContext.DisposalToken);
+
+            await searcher.SearchAsync(cancellationToken).ConfigureAwait(false);
+
+            return graphBuilder;
+        }
 
-        public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext context, CancellationToken cancellationToken)
+        private async Task<GraphBuilder> SearchUsingSymbolsAsync(Solution solution, IGraphContext context, CancellationToken cancellationToken)
         {
             var graphBuilder = await GraphBuilder.CreateForInputNodesAsync(solution, context.InputNodes, cancellationToken).ConfigureAwait(false);
 
@@ -56,11 +92,13 @@ private async Task ProcessProjectAsync(Project project, GraphBuilder graphBuilde
                         {
                             await AddLinkedNodeForTypeAsync(
                                 project, namedType, graphBuilder,
-                                symbol.DeclaringSyntaxReferences.Select(d => d.SyntaxTree)).ConfigureAwait(false);
+                                symbol.DeclaringSyntaxReferences.Select(d => d.SyntaxTree),
+                                cancellationToken).ConfigureAwait(false);
                         }
                         else
                         {
-                            await AddLinkedNodeForMemberAsync(project, symbol, graphBuilder).ConfigureAwait(false);
+                            await AddLinkedNodeForMemberAsync(
+                                project, symbol, graphBuilder, cancellationToken).ConfigureAwait(false);
                         }
                     }
                 }
@@ -68,30 +106,32 @@ await AddLinkedNodeForTypeAsync(
         }
 
         private async Task<GraphNode> AddLinkedNodeForTypeAsync(
-            Project project, INamedTypeSymbol namedType, GraphBuilder graphBuilder, IEnumerable<SyntaxTree> syntaxTrees)
+            Project project, INamedTypeSymbol namedType, GraphBuilder graphBuilder,
+            IEnumerable<SyntaxTree> syntaxTrees, CancellationToken cancellationToken)
         {
             // If this named type is contained in a parent type, then just link farther up
             if (namedType.ContainingType != null)
             {
                 var parentTypeNode = await AddLinkedNodeForTypeAsync(
-                    project, namedType.ContainingType, graphBuilder, syntaxTrees).ConfigureAwait(false);
-                var typeNode = await graphBuilder.AddNodeAsync(namedType, relatedNode: parentTypeNode).ConfigureAwait(false);
-                graphBuilder.AddLink(parentTypeNode, GraphCommonSchema.Contains, typeNode);
+                    project, namedType.ContainingType, graphBuilder, syntaxTrees, cancellationToken).ConfigureAwait(false);
+                var typeNode = await graphBuilder.AddNodeAsync(namedType, relatedNode: parentTypeNode, cancellationToken).ConfigureAwait(false);
+                graphBuilder.AddLink(parentTypeNode, GraphCommonSchema.Contains, typeNode, cancellationToken);
 
                 return typeNode;
             }
             else
             {
                 // From here, we can link back up to the containing project item
-                var typeNode = await graphBuilder.AddNodeAsync(namedType, contextProject: project, contextDocument: null).ConfigureAwait(false);
+                var typeNode = await graphBuilder.AddNodeAsync(
+                    namedType, contextProject: project, contextDocument: null, cancellationToken).ConfigureAwait(false);
 
                 foreach (var tree in syntaxTrees)
                 {
                     var document = project.Solution.GetDocument(tree);
                     Contract.ThrowIfNull(document);
 
-                    var documentNode = graphBuilder.AddNodeForDocument(document);
-                    graphBuilder.AddLink(documentNode, GraphCommonSchema.Contains, typeNode);
+                    var documentNode = graphBuilder.AddNodeForDocument(document, cancellationToken);
+                    graphBuilder.AddLink(documentNode, GraphCommonSchema.Contains, typeNode, cancellationToken);
                 }
 
                 return typeNode;
@@ -99,7 +139,7 @@ private async Task<GraphNode> AddLinkedNodeForTypeAsync(
         }
 
         private async Task<GraphNode> AddLinkedNodeForMemberAsync(
-            Project project, ISymbol symbol, GraphBuilder graphBuilder)
+            Project project, ISymbol symbol, GraphBuilder graphBuilder, CancellationToken cancellationToken)
         {
             var member = symbol;
             Contract.ThrowIfNull(member.ContainingType);
@@ -107,10 +147,10 @@ private async Task<GraphNode> AddLinkedNodeForMemberAsync(
             var trees = member.DeclaringSyntaxReferences.Select(d => d.SyntaxTree);
 
             var parentTypeNode = await AddLinkedNodeForTypeAsync(
-                project, member.ContainingType, graphBuilder, trees).ConfigureAwait(false);
+                project, member.ContainingType, graphBuilder, trees, cancellationToken).ConfigureAwait(false);
             var memberNode = await graphBuilder.AddNodeAsync(
-                symbol, relatedNode: parentTypeNode).ConfigureAwait(false);
-            graphBuilder.AddLink(parentTypeNode, GraphCommonSchema.Contains, memberNode);
+                symbol, relatedNode: parentTypeNode, cancellationToken).ConfigureAwait(false);
+            graphBuilder.AddLink(parentTypeNode, GraphCommonSchema.Contains, memberNode, cancellationToken);
 
             return memberNode;
         }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs
index 5ef2e76226cf9..496a36eba710b 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs
@@ -169,9 +169,9 @@ private static async Task PopulateContextGraphAsync(Solution solution, List<IGra
 
                 foreach (var graphBuilder in graphBuilders)
                 {
-                    graphBuilder.ApplyToGraph(context.Graph);
+                    graphBuilder.ApplyToGraph(context.Graph, cancellationToken);
 
-                    context.OutputNodes.AddAll(graphBuilder.CreatedNodes);
+                    context.OutputNodes.AddAll(graphBuilder.GetCreatedNodes(cancellationToken));
                 }
 
                 transaction.Complete();
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/ProgressionOptions.cs b/src/VisualStudio/Core/Def/Implementation/Progression/ProgressionOptions.cs
new file mode 100644
index 0000000000000..94a3c73b535cf
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/ProgressionOptions.cs
@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.Progression
+{
+    internal static class ProgressionOptions
+    {
+        private const string LocalRegistryPath = @"Roslyn\Internal\OnOff\Components\Progression\";
+
+        public static readonly Option2<bool> SearchUsingNavigateToEngine = new(
+            nameof(ProgressionOptions), nameof(SearchUsingNavigateToEngine), defaultValue: false,
+            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "SearchUsingNavigateToEngine"));
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/ProgressionOptionsProvider.cs b/src/VisualStudio/Core/Def/Implementation/Progression/ProgressionOptionsProvider.cs
new file mode 100644
index 0000000000000..51b4ba2457866
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/ProgressionOptionsProvider.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Options.Providers;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.Progression
+{
+    [ExportOptionProvider, Shared]
+    internal class ProgressionOptionsProvider : IOptionProvider
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public ProgressionOptionsProvider()
+        {
+        }
+
+        public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
+            ProgressionOptions.SearchUsingNavigateToEngine);
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioProject.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioProject.cs
index 6abc3be7a5918..110089eb3c1d3 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioProject.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioProject.cs
@@ -234,7 +234,7 @@ private static void TryReportCompilationThrownAway(SolutionState solutionState,
             // We log the number of syntax trees that have been parsed even if there was no compilation created yet
             var projectState = solutionState.GetRequiredProjectState(projectId);
             var parsedTrees = 0;
-            foreach (var documentState in projectState.DocumentStates.States)
+            foreach (var (_, documentState) in projectState.DocumentStates.States)
             {
                 if (documentState.TryGetSyntaxTree(out _))
                 {
diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
index cecf5cae341f3..5c8b43b3f2553 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -73,8 +73,8 @@ internal abstract partial class VisualStudioWorkspaceImpl : VisualStudioWorkspac
 
         private ImmutableDictionary<ProjectId, IVsHierarchy?> _projectToHierarchyMap = ImmutableDictionary<ProjectId, IVsHierarchy?>.Empty;
         private ImmutableDictionary<ProjectId, Guid> _projectToGuidMap = ImmutableDictionary<ProjectId, Guid>.Empty;
-        private readonly Dictionary<ProjectId, string?> _projectToMaxSupportedLangVersionMap = new();
-        private readonly Dictionary<ProjectId, string> _projectToDependencyNodeTargetIdentifier = new();
+        private ImmutableDictionary<ProjectId, string?> _projectToMaxSupportedLangVersionMap = ImmutableDictionary<ProjectId, string?>.Empty;
+        private ImmutableDictionary<ProjectId, string> _projectToDependencyNodeTargetIdentifier = ImmutableDictionary<ProjectId, string>.Empty;
 
         /// <summary>
         /// A map to fetch the path to a rule set file for a project. This right now is only used to implement
@@ -101,6 +101,8 @@ internal abstract partial class VisualStudioWorkspaceImpl : VisualStudioWorkspac
         [Obsolete("This is a compatibility shim for TypeScript; please do not use it.")]
         internal VisualStudioProjectTracker? _projectTracker;
 
+        private VirtualMemoryNotificationListener? _memoryListener;
+
         private OpenFileTracker? _openFileTracker;
         internal FileChangeWatcher FileChangeWatcher { get; }
         internal FileWatchedPortableExecutableReferenceFactory FileWatchedReferenceFactory { get; }
@@ -204,6 +206,14 @@ public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asy
                 _openFileTracker = openFileTracker;
             }
 
+            var memoryListener = await VirtualMemoryNotificationListener.CreateAsync(this, _threadingContext, asyncServiceProvider, _threadingContext.DisposalToken).ConfigureAwait(true);
+
+            // Update our fields first, so any asynchronous work that needs to use these is able to see the service.
+            lock (_gate)
+            {
+                _memoryListener = memoryListener;
+            }
+
             openFileTracker.ProcessQueuedWorkOnUIThread();
         }
 
@@ -1305,10 +1315,9 @@ internal override Guid GetProjectGuid(ProjectId projectId)
 
         internal string? TryGetDependencyNodeTargetIdentifier(ProjectId projectId)
         {
-            lock (_gate)
-            {
-                return _projectToDependencyNodeTargetIdentifier.GetValueOrDefault(projectId, defaultValue: null);
-            }
+            // This doesn't take a lock since _projectToDependencyNodeTargetIdentifier is immutable
+            _projectToDependencyNodeTargetIdentifier.TryGetValue(projectId, out var identifier);
+            return identifier;
         }
 
         internal override void SetDocumentContext(DocumentId documentId)
@@ -1589,8 +1598,10 @@ protected internal override void OnProjectRemoved(ProjectId projectId)
 
                 _projectToHierarchyMap = _projectToHierarchyMap.Remove(projectId);
                 _projectToGuidMap = _projectToGuidMap.Remove(projectId);
-                _projectToMaxSupportedLangVersionMap.Remove(projectId);
-                _projectToDependencyNodeTargetIdentifier.Remove(projectId);
+                // _projectToMaxSupportedLangVersionMap needs to be updated with ImmutableInterlocked since it can be mutated outside the lock
+                ImmutableInterlocked.TryRemove<ProjectId, string?>(ref _projectToMaxSupportedLangVersionMap, projectId, out _);
+                // _projectToDependencyNodeTargetIdentifier needs to be updated with ImmutableInterlocked since it can be mutated outside the lock
+                ImmutableInterlocked.TryRemove(ref _projectToDependencyNodeTargetIdentifier, projectId, out _);
                 _projectToRuleSetFilePath.Remove(projectId);
 
                 foreach (var (projectName, projects) in _projectSystemNameToProjectsMap)
@@ -1986,20 +1997,22 @@ internal async Task EnsureDocumentOptionProvidersInitializedAsync(CancellationTo
             RegisterDocumentOptionProviders(_documentOptionsProviderFactories);
         }
 
+        [PerformanceSensitive("https://github.com/dotnet/roslyn/issues/54137", AllowLocks = false)]
         internal void SetMaxLanguageVersion(ProjectId projectId, string? maxLanguageVersion)
         {
-            lock (_gate)
-            {
-                _projectToMaxSupportedLangVersionMap[projectId] = maxLanguageVersion;
-            }
+            ImmutableInterlocked.Update(
+                ref _projectToMaxSupportedLangVersionMap,
+                static (map, arg) => map.SetItem(arg.projectId, arg.maxLanguageVersion),
+                (projectId, maxLanguageVersion));
         }
 
+        [PerformanceSensitive("https://github.com/dotnet/roslyn/issues/54135", AllowLocks = false)]
         internal void SetDependencyNodeTargetIdentifier(ProjectId projectId, string targetIdentifier)
         {
-            lock (_gate)
-            {
-                _projectToDependencyNodeTargetIdentifier[projectId] = targetIdentifier;
-            }
+            ImmutableInterlocked.Update(
+                ref _projectToDependencyNodeTargetIdentifier,
+                static (map, arg) => map.SetItem(arg.projectId, arg.targetIdentifier),
+                (projectId, targetIdentifier));
         }
 
         internal void RefreshProjectExistsUIContextForLanguage(string language)
diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectTelemetry/VisualStudioProjectTelemetryService.cs b/src/VisualStudio/Core/Def/Implementation/ProjectTelemetry/VisualStudioProjectTelemetryService.cs
index 61b714b413b33..f29c8a9d05d17 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectTelemetry/VisualStudioProjectTelemetryService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectTelemetry/VisualStudioProjectTelemetryService.cs
@@ -16,6 +16,7 @@
 using Microsoft.CodeAnalysis.ProjectTelemetry;
 using Microsoft.CodeAnalysis.Remote;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.Internal.VisualStudio.Shell;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 using Roslyn.Utilities;
@@ -58,13 +59,15 @@ internal class VisualStudioProjectTelemetryService
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public VisualStudioProjectTelemetryService(
             VisualStudioWorkspaceImpl workspace,
-            IThreadingContext threadingContext) : base(threadingContext)
+            IThreadingContext threadingContext,
+            IAsynchronousOperationListenerProvider asynchronousOperationListenerProvider) : base(threadingContext)
         {
             _workspace = workspace;
 
             _workQueue = new AsyncBatchingWorkQueue<ProjectTelemetryData>(
                 TimeSpan.FromSeconds(1),
                 NotifyTelemetryServiceAsync,
+                asynchronousOperationListenerProvider.GetListener(FeatureAttribute.Telemetry),
                 threadingContext.DisposalToken);
         }
 
@@ -117,7 +120,7 @@ private async Task StartWorkerAsync()
                 cancellationToken).ConfigureAwait(false);
         }
 
-        private async Task NotifyTelemetryServiceAsync(
+        private async ValueTask NotifyTelemetryServiceAsync(
             ImmutableArray<ProjectTelemetryData> infos, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
diff --git a/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs b/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs
index 5f5fda2abed13..02b2b54c05b97 100644
--- a/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs
@@ -739,6 +739,12 @@ private static async Task<ImmutableArray<ISymbol>> GetReferencedSymbolsToLeftOfC
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
             var token = await semanticModel.SyntaxTree.GetTouchingWordAsync(caretPosition.Position, document.GetRequiredLanguageService<ISyntaxFactsService>(), cancellationToken).ConfigureAwait(false);
+            if (token.RawKind == 0)
+            {
+                // There is no touching word, so return empty immediately
+                return ImmutableArray<ISymbol>.Empty;
+            }
+
             var semanticInfo = semanticModel.GetSemanticInfo(token, document.Project.Solution.Workspace, cancellationToken);
             return semanticInfo.ReferencedSymbols;
         }
diff --git a/src/VisualStudio/Core/Def/Implementation/TableDataSource/MiscellaneousDiagnosticListTable.cs b/src/VisualStudio/Core/Def/Implementation/TableDataSource/MiscellaneousDiagnosticListTable.cs
index d58222681a904..18e29d1645198 100644
--- a/src/VisualStudio/Core/Def/Implementation/TableDataSource/MiscellaneousDiagnosticListTable.cs
+++ b/src/VisualStudio/Core/Def/Implementation/TableDataSource/MiscellaneousDiagnosticListTable.cs
@@ -34,8 +34,8 @@ private sealed class MiscellaneousDiagnosticListTable : VisualStudioBaseDiagnost
         {
             private readonly LiveTableDataSource _source;
 
-            public MiscellaneousDiagnosticListTable(Workspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider) :
-                base(workspace, provider)
+            public MiscellaneousDiagnosticListTable(Workspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider)
+                : base(workspace, provider)
             {
                 _source = new LiveTableDataSource(workspace, diagnosticService, IdentifierString);
 
diff --git a/src/VisualStudio/Core/Def/Implementation/TableDataSource/MiscellaneousTodoListTable.cs b/src/VisualStudio/Core/Def/Implementation/TableDataSource/MiscellaneousTodoListTable.cs
index 8a92d5d82de14..6a431243b7fa2 100644
--- a/src/VisualStudio/Core/Def/Implementation/TableDataSource/MiscellaneousTodoListTable.cs
+++ b/src/VisualStudio/Core/Def/Implementation/TableDataSource/MiscellaneousTodoListTable.cs
@@ -31,8 +31,8 @@ public void StartListening(Workspace workspace, ITodoListProvider service)
 
         private sealed class MiscellaneousTodoListTable : VisualStudioBaseTodoListTable
         {
-            public MiscellaneousTodoListTable(Workspace workspace, ITodoListProvider todoListProvider, ITableManagerProvider provider) :
-                base(workspace, todoListProvider, IdentifierString, provider)
+            public MiscellaneousTodoListTable(Workspace workspace, ITodoListProvider todoListProvider, ITableManagerProvider provider)
+                : base(workspace, todoListProvider, IdentifierString, provider)
             {
                 ConnectWorkspaceEvents();
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioBaseDiagnosticListTable.cs b/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioBaseDiagnosticListTable.cs
index 18186f1bfa44f..9ad21793b05f3 100644
--- a/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioBaseDiagnosticListTable.cs
+++ b/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioBaseDiagnosticListTable.cs
@@ -34,8 +34,8 @@ internal abstract partial class VisualStudioBaseDiagnosticListTable : AbstractTa
             StandardTableColumnDefinitions.SuppressionState
         };
 
-        protected VisualStudioBaseDiagnosticListTable(Workspace workspace, ITableManagerProvider provider) :
-            base(workspace, provider, StandardTables.ErrorsTable)
+        protected VisualStudioBaseDiagnosticListTable(Workspace workspace, ITableManagerProvider provider)
+            : base(workspace, provider, StandardTables.ErrorsTable)
         {
         }
 
diff --git a/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioDiagnosticListTable.BuildTableDataSource.cs b/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioDiagnosticListTable.BuildTableDataSource.cs
index bb04f29635839..351cfcc868b05 100644
--- a/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioDiagnosticListTable.BuildTableDataSource.cs
+++ b/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioDiagnosticListTable.BuildTableDataSource.cs
@@ -126,8 +126,8 @@ private class TableEntriesSnapshot : AbstractTableEntriesSnapshot<DiagnosticTabl
                     private readonly DiagnosticTableEntriesSource _source;
 
                     public TableEntriesSnapshot(
-                        DiagnosticTableEntriesSource source, int version, ImmutableArray<DiagnosticTableItem> items) :
-                        base(version, items, ImmutableArray<ITrackingPoint>.Empty)
+                        DiagnosticTableEntriesSource source, int version, ImmutableArray<DiagnosticTableItem> items)
+                        : base(version, items, ImmutableArray<ITrackingPoint>.Empty)
                     {
                         _source = source;
                     }
diff --git a/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioDiagnosticListTable.cs b/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioDiagnosticListTable.cs
index 0401859b94c41..1ff234ca8b85c 100644
--- a/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioDiagnosticListTable.cs
+++ b/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioDiagnosticListTable.cs
@@ -79,8 +79,8 @@ public VisualStudioDiagnosticListTable(
                 VisualStudioWorkspaceImpl workspace,
                 IDiagnosticService diagnosticService,
                 ITableManagerProvider provider,
-                IErrorList errorList) :
-                base(workspace, provider)
+                IErrorList errorList)
+                : base(workspace, provider)
             {
                 _errorList = errorList;
 
@@ -104,15 +104,15 @@ private ITableDataSource GetCurrentDataSource()
             }
 
             /// this is for test only
-            internal VisualStudioDiagnosticListTable(Workspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider) :
-                base(workspace, provider)
+            internal VisualStudioDiagnosticListTable(Workspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider)
+                : base(workspace, provider)
             {
                 AddInitialTableSource(workspace.CurrentSolution, new LiveTableDataSource(workspace, diagnosticService, IdentifierString));
             }
 
             /// this is for test only
-            internal VisualStudioDiagnosticListTable(Workspace workspace, ExternalErrorDiagnosticUpdateSource errorSource, ITableManagerProvider provider) :
-                base(workspace, provider)
+            internal VisualStudioDiagnosticListTable(Workspace workspace, ExternalErrorDiagnosticUpdateSource errorSource, ITableManagerProvider provider)
+                : base(workspace, provider)
             {
                 AddInitialTableSource(workspace.CurrentSolution, new BuildTableDataSource(workspace, errorSource));
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioTodoListTable.cs b/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioTodoListTable.cs
index a6e98ac5c464f..850ca550b0157 100644
--- a/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioTodoListTable.cs
+++ b/src/VisualStudio/Core/Def/Implementation/TableDataSource/VisualStudioTodoListTable.cs
@@ -32,8 +32,8 @@ public void StartListening(Workspace workspace, ITodoListProvider service)
         internal class VisualStudioTodoListTable : VisualStudioBaseTodoListTable
         {
             // internal for testing
-            internal VisualStudioTodoListTable(Workspace workspace, ITodoListProvider todoListProvider, ITableManagerProvider provider) :
-                base(workspace, todoListProvider, IdentifierString, provider)
+            internal VisualStudioTodoListTable(Workspace workspace, ITodoListProvider todoListProvider, ITableManagerProvider provider)
+                : base(workspace, todoListProvider, IdentifierString, provider)
             {
                 ConnectWorkspaceEvents();
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/TodoComments/VisualStudioTodoCommentsService.cs b/src/VisualStudio/Core/Def/Implementation/TodoComments/VisualStudioTodoCommentsService.cs
index 29c0c6b63ced8..4463117ab20ba 100644
--- a/src/VisualStudio/Core/Def/Implementation/TodoComments/VisualStudioTodoCommentsService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/TodoComments/VisualStudioTodoCommentsService.cs
@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.CodeAnalysis.TodoComments;
 using Microsoft.VisualStudio.LanguageServices.ExternalAccess.VSTypeScript.Api;
@@ -38,9 +39,8 @@ internal class VisualStudioTodoCommentsService
     {
         private readonly VisualStudioWorkspaceImpl _workspace;
         private readonly EventListenerTracker<ITodoListProvider> _eventListenerTracker;
-
-        private readonly ConcurrentDictionary<DocumentId, ImmutableArray<TodoCommentData>> _documentToInfos
-            = new();
+        private readonly IAsynchronousOperationListener _asyncListener;
+        private readonly ConcurrentDictionary<DocumentId, ImmutableArray<TodoCommentData>> _documentToInfos = new();
 
         /// <summary>
         /// Remote service connection. Created on demand when we startup and then
@@ -61,11 +61,13 @@ private readonly TaskCompletionSource<AsyncBatchingWorkQueue<DocumentAndComments
         public VisualStudioTodoCommentsService(
             VisualStudioWorkspaceImpl workspace,
             IThreadingContext threadingContext,
+            IAsynchronousOperationListenerProvider asynchronousOperationListenerProvider,
             [ImportMany] IEnumerable<Lazy<IEventListener, EventListenerMetadata>> eventListeners)
             : base(threadingContext)
         {
             _workspace = workspace;
             _eventListenerTracker = new EventListenerTracker<ITodoListProvider>(eventListeners, WellKnownEventListeners.TodoListProvider);
+            _asyncListener = asynchronousOperationListenerProvider.GetListener(FeatureAttribute.TodoCommentList);
         }
 
         public void Dispose()
@@ -106,6 +108,7 @@ private async Task StartWorkerAsync()
                 new AsyncBatchingWorkQueue<DocumentAndComments>(
                     TimeSpan.FromSeconds(1),
                     ProcessTodoCommentInfosAsync,
+                    _asyncListener,
                     cancellationToken));
 
             var client = await RemoteHostClient.TryGetClientAsync(_workspace, cancellationToken).ConfigureAwait(false);
@@ -142,7 +145,7 @@ private void ComputeTodoCommentsInCurrentProcess(CancellationToken cancellationT
                     workspaceKinds: WorkspaceKind.Host));
         }
 
-        private Task ProcessTodoCommentInfosAsync(
+        private ValueTask ProcessTodoCommentInfosAsync(
             ImmutableArray<DocumentAndComments> docAndCommentsArray, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -181,7 +184,7 @@ private Task ProcessTodoCommentInfosAsync(
                 }
             }
 
-            return Task.CompletedTask;
+            return ValueTaskFactory.CompletedTask;
         }
 
         private void AddFilteredInfos(
diff --git a/src/VisualStudio/Core/Def/Implementation/UnusedReferences/Dialog/UnusedReferencesTableProvider.DataSource.cs b/src/VisualStudio/Core/Def/Implementation/UnusedReferences/Dialog/UnusedReferencesTableProvider.DataSource.cs
index ca4ee097e3db9..b7781005e2a44 100644
--- a/src/VisualStudio/Core/Def/Implementation/UnusedReferences/Dialog/UnusedReferencesTableProvider.DataSource.cs
+++ b/src/VisualStudio/Core/Def/Implementation/UnusedReferences/Dialog/UnusedReferencesTableProvider.DataSource.cs
@@ -123,8 +123,10 @@ public bool TryGetValue(string keyName, out object? content)
                             content = ReferenceUpdate.ReferenceInfo.ReferenceType;
                             break;
                         case UnusedReferencesTableKeyNames.ReferenceName:
-                            // It is unnecessary to display the full path to project and assembly files.
-                            content = Path.GetFileNameWithoutExtension(ReferenceUpdate.ReferenceInfo.ItemSpecification);
+                            // For Project and Assembly references, use the file name instead of overwhelming the user with the full path.
+                            content = ReferenceUpdate.ReferenceInfo.ReferenceType != ReferenceType.Package
+                                ? Path.GetFileName(ReferenceUpdate.ReferenceInfo.ItemSpecification)
+                                : ReferenceUpdate.ReferenceInfo.ItemSpecification;
                             break;
                         case UnusedReferencesTableKeyNames.UpdateAction:
                             content = ReferenceUpdate.Action;
diff --git a/src/VisualStudio/Core/Def/Implementation/UnusedReferences/ProjectAssets/ProjectAssetsReader.cs b/src/VisualStudio/Core/Def/Implementation/UnusedReferences/ProjectAssets/ProjectAssetsReader.cs
index 4db7302726166..6dc53cda7f586 100644
--- a/src/VisualStudio/Core/Def/Implementation/UnusedReferences/ProjectAssets/ProjectAssetsReader.cs
+++ b/src/VisualStudio/Core/Def/Implementation/UnusedReferences/ProjectAssets/ProjectAssetsReader.cs
@@ -66,7 +66,8 @@ internal static ImmutableArray<ReferenceInfo> ReadReferences(
             }
 
             var autoReferences = projectAssets.Project?.Frameworks?.Values
-                .SelectMany(framework => framework.Dependencies?.Keys.Where(key => framework.Dependencies[key].AutoReferenced))
+                .Where(framework => framework.Dependencies != null)
+                .SelectMany(framework => framework.Dependencies!.Keys.Where(key => framework.Dependencies[key].AutoReferenced))
                 .Distinct()
                 .ToImmutableHashSet();
             autoReferences ??= ImmutableHashSet<string>.Empty;
diff --git a/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs b/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs
index 198cc448de094..9113ca6b9c011 100644
--- a/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs
+++ b/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs
@@ -2,26 +2,22 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
-using System.Composition;
 using System.Runtime;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Extensions;
 using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
-using Microsoft.CodeAnalysis.Remote;
 using Microsoft.CodeAnalysis.Shared.Options;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.VisualStudio.LanguageServices.Implementation;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
-using Microsoft.VisualStudio.LanguageServices.Remote;
-using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
+using IAsyncServiceProvider = Microsoft.VisualStudio.Shell.IAsyncServiceProvider;
 
 namespace Microsoft.VisualStudio.LanguageServices
 {
@@ -29,7 +25,6 @@ namespace Microsoft.VisualStudio.LanguageServices
     /// Listens to broadcast notifications from the Visual Studio Shell indicating that the application is running
     /// low on available virtual memory.
     /// </summary>
-    [Export, Shared]
     internal sealed class VirtualMemoryNotificationListener : ForegroundThreadAffinitizedObject, IVsBroadcastMessageEvents
     {
         // memory threshold to turn off full solution analysis - 200MB
@@ -39,15 +34,13 @@ internal sealed class VirtualMemoryNotificationListener : ForegroundThreadAffini
         private const string LowVMMoreInfoLink = "https://go.microsoft.com/fwlink/?LinkID=799402&clcid=0x409";
 
         private readonly VisualStudioWorkspace _workspace;
-        private readonly WorkspaceCacheService _workspaceCacheService;
+        private readonly WorkspaceCacheService? _workspaceCacheService;
 
         private bool _alreadyLogged;
 
-        [ImportingConstructor]
-        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public VirtualMemoryNotificationListener(
+        private VirtualMemoryNotificationListener(
             IThreadingContext threadingContext,
-            SVsServiceProvider serviceProvider,
+            IVsShell shell,
             VisualStudioWorkspace workspace)
             : base(threadingContext, assertIsForeground: true)
         {
@@ -63,11 +56,20 @@ public VirtualMemoryNotificationListener(
 
             _workspace.WorkspaceChanged += OnWorkspaceChanged;
 
-            var shell = (IVsShell)serviceProvider.GetService(typeof(SVsShell));
             // Note: We never unhook this event sink. It lives for the lifetime of the host.
             ErrorHandler.ThrowOnFailure(shell.AdviseBroadcastMessages(this, out var cookie));
         }
 
+        public static async Task<VirtualMemoryNotificationListener> CreateAsync(VisualStudioWorkspace workspace, IThreadingContext threadingContext, IAsyncServiceProvider serviceProvider, CancellationToken cancellationToken)
+        {
+            await threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var shell = (IVsShell?)await serviceProvider.GetServiceAsync(typeof(SVsShell)).ConfigureAwait(true);
+            Assumes.Present(shell);
+
+            return new VirtualMemoryNotificationListener(threadingContext, shell, workspace);
+        }
+
         /// <summary>
         /// Called by the Visual Studio Shell to notify components of a broadcast message.
         /// </summary>
@@ -149,7 +151,7 @@ private void ShowInfoBarIfRequired()
             }
 
             // Show info bar.
-            _workspace.Services.GetService<IErrorReportingService>()
+            _workspace.Services.GetRequiredService<IErrorReportingService>()
                 .ShowGlobalErrorInfo(ServicesVSResources.Visual_Studio_has_suspended_some_advanced_features_to_improve_performance,
                     new InfoBarUI(ServicesVSResources.Re_enable, InfoBarUI.UIKind.Button, RenableBackgroundAnalysis),
                     new InfoBarUI(ServicesVSResources.Learn_more, InfoBarUI.UIKind.HyperLink,
diff --git a/src/VisualStudio/Core/Def/Implementation/Workspace/SourceGeneratedFileManager.cs b/src/VisualStudio/Core/Def/Implementation/Workspace/SourceGeneratedFileManager.cs
index 2dad6684c85fe..25309ad0dfa83 100644
--- a/src/VisualStudio/Core/Def/Implementation/Workspace/SourceGeneratedFileManager.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Workspace/SourceGeneratedFileManager.cs
@@ -9,6 +9,7 @@
 using System.IO;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
@@ -191,7 +192,7 @@ void IRunningDocumentTableEventListener.OnOpenDocument(string moniker, ITextBuff
                     openFile = new OpenSourceGeneratedFile(this, textBuffer, _visualStudioWorkspace, documentIdentity, _threadingContext);
                     _openFiles.Add(moniker, openFile);
 
-                    _threadingContext.JoinableTaskFactory.Run(() => openFile.RefreshFileAsync(CancellationToken.None));
+                    _threadingContext.JoinableTaskFactory.Run(() => openFile.RefreshFileAsync(CancellationToken.None).AsTask());
 
                     // Update the RDT flags to ensure the file can't be saved or appears in any MRUs as it's a temporary generated file name.
                     var cookie = ((IVsRunningDocumentTable4)_runningDocumentTable).GetDocumentCookie(moniker);
@@ -247,7 +248,7 @@ private class OpenSourceGeneratedFile : ForegroundThreadAffinitizedObject, IDisp
             /// <summary>
             /// A queue used to batch updates to the file.
             /// </summary>
-            private readonly AsyncBatchingDelay _batchingWorkQueue;
+            private readonly AsyncBatchingWorkQueue _batchingWorkQueue;
 
             /// <summary>
             /// The <see cref="IVsWindowFrame"/> of the active window. This may be null if we're in the middle of construction and
@@ -284,7 +285,7 @@ public OpenSourceGeneratedFile(SourceGeneratedFileManager fileManager, ITextBuff
 
                 _workspace.WorkspaceChanged += OnWorkspaceChanged;
 
-                _batchingWorkQueue = new AsyncBatchingDelay(
+                _batchingWorkQueue = new AsyncBatchingWorkQueue(
                     TimeSpan.FromSeconds(1),
                     RefreshFileAsync,
                     asyncListener: _fileManager._listener,
@@ -321,7 +322,7 @@ public void Dispose()
 
             private string GeneratorDisplayName => _documentIdentity.GeneratorTypeName;
 
-            public async Task RefreshFileAsync(CancellationToken cancellationToken)
+            public async ValueTask RefreshFileAsync(CancellationToken cancellationToken)
             {
                 SourceText? generatedSource = null;
                 var project = _workspace.CurrentSolution.GetProject(_documentIdentity.DocumentId.ProjectId);
@@ -436,7 +437,7 @@ private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs e)
                         if (await oldProject.GetDependentVersionAsync(_cancellationTokenSource.Token).ConfigureAwait(false) !=
                             await newProject.GetDependentVersionAsync(_cancellationTokenSource.Token).ConfigureAwait(false))
                         {
-                            _batchingWorkQueue.RequeueWork();
+                            _batchingWorkQueue.AddWork();
                         }
                     }, _cancellationTokenSource.Token).CompletesAsyncOperation(asyncToken);
                 }
diff --git a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioProjectCacheHostServiceFactory.cs b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioProjectCacheHostServiceFactory.cs
index 23b3b6b1a8f8e..3d9a0808a469d 100644
--- a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioProjectCacheHostServiceFactory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioProjectCacheHostServiceFactory.cs
@@ -16,7 +16,7 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.Workspaces
     [Shared]
     internal partial class VisualStudioProjectCacheHostServiceFactory : IWorkspaceServiceFactory
     {
-        private const int ImplicitCacheTimeoutInMS = 10000;
+        private static readonly TimeSpan ImplicitCacheTimeout = TimeSpan.FromMilliseconds(10000);
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
@@ -42,7 +42,7 @@ private static IWorkspaceService GetMiscProjectCache(HostWorkspaceServices works
                 return new ProjectCacheService(workspaceServices.Workspace);
             }
 
-            var projectCacheService = new ProjectCacheService(workspaceServices.Workspace, ImplicitCacheTimeoutInMS);
+            var projectCacheService = new ProjectCacheService(workspaceServices.Workspace, ImplicitCacheTimeout);
 
             // Also clear the cache when the solution is cleared or removed.
             workspaceServices.Workspace.WorkspaceChanged += (s, e) =>
@@ -59,7 +59,7 @@ private static IWorkspaceService GetMiscProjectCache(HostWorkspaceServices works
         private static IWorkspaceService GetVisualStudioProjectCache(HostWorkspaceServices workspaceServices)
         {
             // We will finish setting this up in VisualStudioWorkspaceImpl.DeferredInitializationState
-            return new ProjectCacheService(workspaceServices.Workspace, ImplicitCacheTimeoutInMS);
+            return new ProjectCacheService(workspaceServices.Workspace, ImplicitCacheTimeout);
         }
 
         internal static void ConnectProjectCacheServiceToDocumentTracking(HostWorkspaceServices workspaceServices, ProjectCacheService projectCacheService)
diff --git a/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj b/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj
index 324c659f597a5..c61ad491ee904 100644
--- a/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj
+++ b/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj
@@ -72,7 +72,9 @@
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.VisualStudio.TestWindow.CodeLens" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.CodeLens" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.CSharp" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Implementation" />
diff --git a/src/VisualStudio/Core/Def/PackageRegistration.pkgdef b/src/VisualStudio/Core/Def/PackageRegistration.pkgdef
index cf0c02e3f8465..423f550810185 100644
--- a/src/VisualStudio/Core/Def/PackageRegistration.pkgdef
+++ b/src/VisualStudio/Core/Def/PackageRegistration.pkgdef
@@ -25,6 +25,12 @@
 "Title"="Enable experimental C#/VB LSP completion experience"
 "PreviewPaneChannels"="IntPreview,int.main"
 
+// The option page configuration is duplicated in RoslynPackage
+// [ProvideToolWindow(typeof(ValueTracking.ValueTrackingToolWindow))]
+[$RootKey$\ToolWindows\{60a19d42-2dd7-43f3-be90-c7a9cb7d28f4}]
+"Name"="Microsoft.VisualStudio.LanguageServices.ValueTracking.ValueTrackingToolWindow"
+@="{6cf2e545-6109-4730-8883-cf43d7aec3e1}"
+
 // 68b46364-d378-42f2-9e72-37d86c5f4468 is the guid for SettingsEditorFactory
 // 6cf2e545-6109-4730-8883-cf43d7aec3e1 is the guid for RoslynPackage
 [$RootKey$\Editors\{68b46364-d378-42f2-9e72-37d86c5f4468}]
diff --git a/src/VisualStudio/Core/Def/Packaging/PackageInstallerServiceFactory.cs b/src/VisualStudio/Core/Def/Packaging/PackageInstallerServiceFactory.cs
index bfa8dd1049081..0a8892990afed 100644
--- a/src/VisualStudio/Core/Def/Packaging/PackageInstallerServiceFactory.cs
+++ b/src/VisualStudio/Core/Def/Packaging/PackageInstallerServiceFactory.cs
@@ -440,7 +440,7 @@ private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs e)
             _workQueue.AddWork((solutionChanged, changedProject));
         }
 
-        private Task ProcessWorkQueueAsync(
+        private ValueTask ProcessWorkQueueAsync(
             ImmutableArray<(bool solutionChanged, ProjectId? changedProject)> workQueue, CancellationToken cancellationToken)
         {
             ThisCanBeCalledOnAnyThread();
@@ -449,13 +449,13 @@ private Task ProcessWorkQueueAsync(
 
             // If we've been disconnected, then there's no point proceeding.
             if (_workspace == null || !IsEnabled)
-                return Task.CompletedTask;
+                return ValueTaskFactory.CompletedTask;
 
             return ProcessWorkQueueWorkerAsync(workQueue, cancellationToken);
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private async Task ProcessWorkQueueWorkerAsync(
+        private async ValueTask ProcessWorkQueueWorkerAsync(
             ImmutableArray<(bool solutionChanged, ProjectId? changedProject)> workQueue, CancellationToken cancellationToken)
         {
             ThisCanBeCalledOnAnyThread();
diff --git a/src/VisualStudio/Core/Def/RoslynPackage.cs b/src/VisualStudio/Core/Def/RoslynPackage.cs
index 3e01cafb3530a..c28ba4669a1bb 100644
--- a/src/VisualStudio/Core/Def/RoslynPackage.cs
+++ b/src/VisualStudio/Core/Def/RoslynPackage.cs
@@ -20,28 +20,23 @@
 using Microsoft.CodeAnalysis.Logging;
 using Microsoft.CodeAnalysis.Notification;
 using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.Remote;
 using Microsoft.CodeAnalysis.Telemetry;
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.LanguageServices.ColorSchemes;
 using Microsoft.VisualStudio.LanguageServices.EditorConfigSettings;
 using Microsoft.VisualStudio.LanguageServices.Experimentation;
 using Microsoft.VisualStudio.LanguageServices.Implementation;
-using Microsoft.VisualStudio.LanguageServices.Implementation.DesignerAttribute;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Diagnostics;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Interactive;
 using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem.RuleSets;
-using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectTelemetry;
 using Microsoft.VisualStudio.LanguageServices.Implementation.TableDataSource;
-using Microsoft.VisualStudio.LanguageServices.Implementation.TodoComments;
 using Microsoft.VisualStudio.LanguageServices.Implementation.UnusedReferences;
 using Microsoft.VisualStudio.LanguageServices.Telemetry;
 using Microsoft.VisualStudio.PlatformUI;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
-using Microsoft.VisualStudio.Shell.ServiceBroker;
 using Microsoft.VisualStudio.TaskStatusCenter;
 using Microsoft.VisualStudio.Telemetry;
 using Microsoft.VisualStudio.TextManager.Interop;
@@ -52,6 +47,9 @@
 namespace Microsoft.VisualStudio.LanguageServices.Setup
 {
     [Guid(Guids.RoslynPackageIdString)]
+
+    // The option page configuration is duplicated in PackageRegistration.pkgdef
+    [ProvideToolWindow(typeof(ValueTracking.ValueTrackingToolWindow))]
     internal sealed class RoslynPackage : AbstractPackage
     {
         // The randomly-generated key name is used for serializing the ILSpy decompiler EULA preference to the .SUO
@@ -186,7 +184,6 @@ protected override async Task LoadComponentsAsync(CancellationToken cancellation
             this.ComponentModel.GetService<VisualStudioDiagnosticListTableCommandHandler>().Initialize(this);
 
             this.ComponentModel.GetService<VisualStudioMetadataAsSourceFileSupportService>();
-            this.ComponentModel.GetService<VirtualMemoryNotificationListener>();
 
             // The misc files workspace needs to be loaded on the UI thread.  This way it will have
             // the appropriate task scheduler to report events on.
@@ -204,6 +201,19 @@ protected override async Task LoadComponentsAsync(CancellationToken cancellation
             LoadComponentsBackgroundAsync(cancellationToken).Forget();
         }
 
+        // Overrides for VSSDK003 fix 
+        // See https://github.com/Microsoft/VSSDK-Analyzers/blob/main/doc/VSSDK003.md
+        public override IVsAsyncToolWindowFactory GetAsyncToolWindowFactory(Guid toolWindowType)
+            => toolWindowType == typeof(ValueTracking.ValueTrackingToolWindow).GUID
+                ? this
+                : base.GetAsyncToolWindowFactory(toolWindowType);
+
+        protected override string GetToolWindowTitle(Type toolWindowType, int id)
+                => base.GetToolWindowTitle(toolWindowType, id);
+
+        protected override Task<object?> InitializeToolWindowAsync(Type toolWindowType, int id, CancellationToken cancellationToken)
+            => Task.FromResult((object?)null);
+
         private async Task LoadComponentsBackgroundAsync(CancellationToken cancellationToken)
         {
             await TaskScheduler.Default;
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index cf374e9343835..caabce2d12c40 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1656,6 +1656,9 @@ I agree to all of the foregoing:</value>
   <data name="Enable_file_logging_for_diagnostics" xml:space="preserve">
     <value>Enable file logging for diagnostics (logged in '%Temp%\Roslyn' folder)</value>
   </data>
+  <data name="Skip_analyzers_for_implicitly_triggered_builds" xml:space="preserve">
+    <value>Skip analyzers for implicitly triggered builds</value>
+  </data>
   <data name="This_action_cannot_be_undone_Do_you_wish_to_continue" xml:space="preserve">
     <value>This action cannot be undone. Do you wish to continue?</value>
   </data>
@@ -1747,4 +1750,27 @@ I agree to all of the foregoing:</value>
   <data name="Overridden_members" xml:space="preserve">
     <value>Overridden members</value>
   </data>
+  <data name="Value_Tracking" xml:space="preserve">
+    <value>Value Tracking</value>
+    <comment>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</comment>
+  </data>
+  <data name="Calculating" xml:space="preserve">
+    <value>Calculating...</value>
+    <comment>Used in UI to represent progress in the context of loading items. </comment>
+  </data>
+  <data name="Derived_types" xml:space="preserve">
+    <value>Derived types</value>
+  </data>
+  <data name="Implemented_interfaces" xml:space="preserve">
+    <value>Implemented interfaces</value>
+  </data>
+  <data name="Implementing_types" xml:space="preserve">
+    <value>Implementing types</value>
+  </data>
+  <data name="Inherited_interfaces" xml:space="preserve">
+    <value>Inherited interfaces</value>
+  </data>
+  <data name="Select_an_appropriate_symbol_to_start_value_tracking" xml:space="preserve">
+    <value>Select an appropriate symbol to start value tracking</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/VisualStudio/Core/Def/Telemetry/VSTelemetryLogger.cs b/src/VisualStudio/Core/Def/Telemetry/VSTelemetryLogger.cs
index b8017f09fba9a..e31883c4499a7 100644
--- a/src/VisualStudio/Core/Def/Telemetry/VSTelemetryLogger.cs
+++ b/src/VisualStudio/Core/Def/Telemetry/VSTelemetryLogger.cs
@@ -4,11 +4,9 @@
 
 #nullable disable
 
-using System;
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Threading;
-using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.VisualStudio.Telemetry;
 using Roslyn.Utilities;
@@ -31,7 +29,7 @@ public bool IsEnabled(FunctionId functionId)
 
         public void Log(FunctionId functionId, LogMessage logMessage)
         {
-            if (logMessage.LogLevel < LogLevel.Information)
+            if (IgnoreMessage(logMessage))
             {
                 return;
             }
@@ -55,7 +53,7 @@ public void Log(FunctionId functionId, LogMessage logMessage)
 
         public void LogBlockStart(FunctionId functionId, LogMessage logMessage, int blockId, CancellationToken cancellationToken)
         {
-            if (!(logMessage is KeyValueLogMessage kvLogMessage))
+            if (IgnoreMessage(logMessage))
             {
                 return;
             }
@@ -63,7 +61,9 @@ public void LogBlockStart(FunctionId functionId, LogMessage logMessage, int bloc
             try
             {
                 // guard us from exception thrown by telemetry
-                _pendingScopes[blockId] = CreateAndStartScope(kvLogMessage.Kind, functionId);
+                var kind = GetKind(logMessage);
+
+                _pendingScopes[blockId] = CreateAndStartScope(kind, functionId);
             }
             catch
             {
@@ -72,7 +72,7 @@ public void LogBlockStart(FunctionId functionId, LogMessage logMessage, int bloc
 
         public void LogBlockEnd(FunctionId functionId, LogMessage logMessage, int blockId, int delta, CancellationToken cancellationToken)
         {
-            if (!(logMessage is KeyValueLogMessage kvLogMessage))
+            if (IgnoreMessage(logMessage))
             {
                 return;
             }
@@ -80,14 +80,15 @@ public void LogBlockEnd(FunctionId functionId, LogMessage logMessage, int blockI
             try
             {
                 // guard us from exception thrown by telemetry
-                var kind = kvLogMessage.Kind;
+                var kind = GetKind(logMessage);
+
                 switch (kind)
                 {
                     case LogType.Trace:
-                        EndScope<OperationEvent>(functionId, blockId, kvLogMessage, cancellationToken);
+                        EndScope<OperationEvent>(functionId, blockId, logMessage, cancellationToken);
                         return;
                     case LogType.UserAction:
-                        EndScope<UserTaskEvent>(functionId, blockId, kvLogMessage, cancellationToken);
+                        EndScope<UserTaskEvent>(functionId, blockId, logMessage, cancellationToken);
                         return;
                     default:
                         throw ExceptionUtilities.UnexpectedValue(kind);
@@ -98,7 +99,19 @@ public void LogBlockEnd(FunctionId functionId, LogMessage logMessage, int blockI
             }
         }
 
-        private void EndScope<T>(FunctionId functionId, int blockId, KeyValueLogMessage kvLogMessage, CancellationToken cancellationToken)
+        private static bool IgnoreMessage(LogMessage logMessage)
+            => logMessage.LogLevel < LogLevel.Information;
+
+        private static LogType GetKind(LogMessage logMessage)
+            => logMessage is KeyValueLogMessage kvLogMessage
+                                ? kvLogMessage.Kind
+                                : logMessage.LogLevel switch
+                                {
+                                    >= LogLevel.Information => LogType.UserAction,
+                                    _ => LogType.Trace
+                                };
+
+        private void EndScope<T>(FunctionId functionId, int blockId, LogMessage logMessage, CancellationToken cancellationToken)
             where T : OperationEvent
         {
             if (!_pendingScopes.TryRemove(blockId, out var value))
@@ -109,7 +122,7 @@ private void EndScope<T>(FunctionId functionId, int blockId, KeyValueLogMessage
 
             var operation = (TelemetryScope<T>)value;
 
-            AppendProperties(operation.EndEvent, functionId, kvLogMessage);
+            UpdateEvent(operation.EndEvent, functionId, logMessage);
             operation.End(cancellationToken.IsCancellationRequested ? TelemetryResult.UserCancel : TelemetryResult.Success);
         }
 
@@ -132,10 +145,24 @@ private static TelemetryEvent CreateTelemetryEvent(FunctionId functionId, LogMes
             var eventName = functionId.GetEventName();
             var telemetryEvent = new TelemetryEvent(eventName);
 
+            return UpdateEvent(telemetryEvent, functionId, logMessage);
+        }
+
+        private static TelemetryEvent UpdateEvent(TelemetryEvent telemetryEvent, FunctionId functionId, LogMessage logMessage)
+        {
             if (logMessage is KeyValueLogMessage kvLogMessage)
             {
                 telemetryEvent = AppendProperties(telemetryEvent, functionId, kvLogMessage);
             }
+            else
+            {
+                var message = logMessage.GetMessage();
+                if (!string.IsNullOrWhiteSpace(message))
+                {
+                    var propertyName = functionId.GetPropertyName("Message");
+                    telemetryEvent.Properties.Add(propertyName, message);
+                }
+            }
 
             return telemetryEvent;
         }
diff --git a/src/VisualStudio/Core/Def/ValueTracking/BindableTextBlock.cs b/src/VisualStudio/Core/Def/ValueTracking/BindableTextBlock.cs
new file mode 100644
index 0000000000000..37f1696f34b32
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/BindableTextBlock.cs
@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using Roslyn.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class BindableTextBlock : TextBlock
+    {
+        public IList<Inline> InlineCollection
+        {
+            get { return (ObservableCollection<Inline>)GetValue(InlineListProperty); }
+            set { SetValue(InlineListProperty, value); }
+        }
+
+        public static readonly DependencyProperty InlineListProperty =
+            DependencyProperty.Register(nameof(InlineCollection), typeof(IList<Inline>), typeof(BindableTextBlock), new UIPropertyMetadata(null, OnPropertyChanged));
+
+        private static void OnPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
+            var textBlock = (BindableTextBlock)sender;
+            var newList = (IList<Inline>)e.NewValue;
+
+            textBlock.Inlines.Clear();
+            foreach (var inline in newList)
+            {
+                textBlock.Inlines.Add(inline);
+            }
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ComputingTreeViewItem.cs b/src/VisualStudio/Core/Def/ValueTracking/ComputingTreeViewItem.cs
new file mode 100644
index 0000000000000..0fcf993b01616
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/ComputingTreeViewItem.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Windows.Threading;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class ComputingTreeViewItem : TreeViewItemBase
+    {
+        public string Text => ServicesVSResources.Calculating;
+
+        public ComputingTreeViewItem()
+        {
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/EmptyTreeViewItem.cs b/src/VisualStudio/Core/Def/ValueTracking/EmptyTreeViewItem.cs
new file mode 100644
index 0000000000000..767ecab7af32f
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/EmptyTreeViewItem.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class EmptyTreeViewItem : TreeViewItemBase
+    {
+        public static EmptyTreeViewItem Instance { get; } = new();
+
+        private EmptyTreeViewItem()
+        {
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/TreeItemViewModel.cs b/src/VisualStudio/Core/Def/ValueTracking/TreeItemViewModel.cs
new file mode 100644
index 0000000000000..4b4267b6988fe
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/TreeItemViewModel.cs
@@ -0,0 +1,143 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.Windows.Documents;
+using System.Windows.Media;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Navigation;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class TreeItemViewModel : TreeViewItemBase
+    {
+        private readonly SourceText _sourceText;
+        private readonly Glyph _glyph;
+        private readonly IGlyphService _glyphService;
+
+        protected ValueTrackingTreeViewModel TreeViewModel { get; }
+        protected TextSpan TextSpan { get; }
+        protected LineSpan LineSpan { get; }
+        protected IThreadingContext ThreadingContext { get; }
+        protected DocumentId DocumentId { get; }
+        protected Workspace Workspace { get; }
+
+        public int LineNumber => LineSpan.Start + 1; // LineSpan is 0 indexed, editors are not
+
+        public string FileName { get; }
+
+        public ImageSource GlyphImage => _glyph.GetImageSource(_glyphService);
+        public bool ShowGlyph => !IsLoading;
+
+        public ImmutableArray<ClassifiedSpan> ClassifiedSpans { get; }
+
+        public ImmutableArray<Inline> Inlines => CalculateInlines();
+
+        public TreeItemViewModel(
+            TextSpan textSpan,
+            SourceText sourceText,
+            DocumentId documentId,
+            string fileName,
+            Glyph glyph,
+            ImmutableArray<ClassifiedSpan> classifiedSpans,
+            ValueTrackingTreeViewModel treeViewModel,
+            IGlyphService glyphService,
+            IThreadingContext threadingContext,
+            Workspace workspace,
+            ImmutableArray<TreeItemViewModel> children = default)
+            : base()
+        {
+            FileName = fileName;
+            TextSpan = textSpan;
+            _sourceText = sourceText;
+            ClassifiedSpans = classifiedSpans;
+            TreeViewModel = treeViewModel;
+            ThreadingContext = threadingContext;
+
+            _glyph = glyph;
+            _glyphService = glyphService;
+            Workspace = workspace;
+            DocumentId = documentId;
+
+            if (!children.IsDefaultOrEmpty)
+            {
+                foreach (var child in children)
+                {
+                    ChildItems.Add(child);
+                }
+            }
+
+            sourceText.GetLineAndOffset(textSpan.Start, out var lineStart, out var _);
+            sourceText.GetLineAndOffset(textSpan.End, out var lineEnd, out var _);
+            LineSpan = LineSpan.FromBounds(lineStart, lineEnd);
+
+            PropertyChanged += (s, e) =>
+            {
+                if (e.PropertyName == nameof(IsLoading))
+                {
+                    NotifyPropertyChanged(nameof(ShowGlyph));
+                }
+            };
+        }
+
+        public virtual void NavigateTo()
+        {
+            var navigationService = Workspace.Services.GetService<IDocumentNavigationService>();
+            if (navigationService is null)
+            {
+                return;
+            }
+
+            // While navigating do not activate the tab, which will change focus from the tool window
+            var options = Workspace.Options
+                .WithChangedOption(new OptionKey(NavigationOptions.PreferProvisionalTab), true)
+                .WithChangedOption(new OptionKey(NavigationOptions.ActivateTab), false);
+
+            navigationService.TryNavigateToLineAndOffset(Workspace, DocumentId, LineSpan.Start, 0, options, ThreadingContext.DisposalToken);
+        }
+
+        private ImmutableArray<Inline> CalculateInlines()
+        {
+            if (ClassifiedSpans.IsDefaultOrEmpty)
+            {
+                return ImmutableArray<Inline>.Empty;
+            }
+
+            var classifiedTexts = ClassifiedSpans.SelectAsArray(
+               cs =>
+               {
+                   return new ClassifiedText(cs.ClassificationType, _sourceText.ToString(cs.TextSpan));
+               });
+
+            var spanStartPosition = TextSpan.Start - ClassifiedSpans[0].TextSpan.Start;
+            var spanEndPosition = TextSpan.End - ClassifiedSpans[0].TextSpan.End;
+
+            return classifiedTexts.ToInlines(
+                TreeViewModel.ClassificationFormatMap,
+                TreeViewModel.ClassificationTypeMap,
+                (run, classifiedText, position) =>
+                {
+                    if (TreeViewModel.HighlightBrush is not null)
+                    {
+                        if (position >= spanStartPosition && position <= spanEndPosition)
+                        {
+                            run.SetValue(
+                                TextElement.BackgroundProperty,
+                                TreeViewModel.HighlightBrush);
+                        }
+                    }
+                }).ToImmutableArray();
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/TreeViewItemBase.cs b/src/VisualStudio/Core/Def/ValueTracking/TreeViewItemBase.cs
new file mode 100644
index 0000000000000..655dd6e2bef15
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/TreeViewItemBase.cs
@@ -0,0 +1,148 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class TreeViewItemBase : INotifyPropertyChanged
+    {
+        public ObservableCollection<TreeViewItemBase> ChildItems { get; } = new();
+        public TreeViewItemBase? Parent { get; set; }
+
+        private bool _isExpanded = false;
+        public virtual bool IsNodeExpanded
+        {
+            get => _isExpanded;
+            set => SetProperty(ref _isExpanded, value);
+        }
+
+        private bool _isSelected = false;
+        public bool IsNodeSelected
+        {
+            get => _isSelected;
+            set => SetProperty(ref _isSelected, value);
+        }
+
+        private bool _isLoading;
+        public bool IsLoading
+        {
+            get => _isLoading;
+            set => SetProperty(ref _isLoading, value);
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public TreeViewItemBase()
+        {
+            ChildItems.CollectionChanged += ChildItems_CollectionChanged;
+        }
+
+        /// <summary>
+        /// Returns the next logical item in the tree that could be seen (Parent is expanded)
+        /// </summary>
+        public TreeViewItemBase GetNextInTree()
+        {
+            if (IsNodeExpanded && ChildItems.Any())
+            {
+                return ChildItems.First();
+            }
+
+            var sibling = GetSibling(next: true);
+            if (sibling is not null)
+            {
+                return sibling;
+            }
+
+            return Parent?.GetSibling(next: true) ?? this;
+        }
+
+        /// <summary>
+        /// Returns the previous logical item in the tree that could be seen (Parent is expanded)
+        /// </summary>
+        public TreeViewItemBase GetPreviousInTree()
+        {
+            var sibling = GetSibling(next: false);
+            if (sibling is not null)
+            {
+                return sibling.GetLastVisibleDescendentOrSelf();
+            }
+
+            return Parent ?? this;
+        }
+
+        private TreeViewItemBase GetLastVisibleDescendentOrSelf()
+        {
+            if (!IsNodeExpanded || ChildItems.Count == 0)
+            {
+                return this;
+            }
+
+            var lastChild = ChildItems.Last();
+            return lastChild.GetLastVisibleDescendentOrSelf();
+        }
+
+        private TreeViewItemBase? GetSibling(bool next = true)
+        {
+            if (Parent is null)
+            {
+                return null;
+            }
+
+            var thisIndex = Parent.ChildItems.IndexOf(this);
+            var siblingIndex = next ? thisIndex + 1 : thisIndex - 1;
+
+            if (siblingIndex < 0 || siblingIndex >= Parent.ChildItems.Count)
+            {
+                return null;
+            }
+
+            return Parent.ChildItems[siblingIndex];
+        }
+
+        private void ChildItems_CollectionChanged(object _, NotifyCollectionChangedEventArgs args)
+        {
+            if (args.Action is not NotifyCollectionChangedAction.Add and not NotifyCollectionChangedAction.Remove)
+            {
+                return;
+            }
+
+            SetParents(args.OldItems, null);
+            SetParents(args.NewItems, this);
+
+            static void SetParents(IList? items, TreeViewItemBase? parent)
+            {
+                if (items is null)
+                {
+                    return;
+                }
+
+                foreach (var item in items.Cast<TreeViewItemBase>())
+                {
+                    item.Parent = parent;
+                }
+            }
+        }
+
+        protected void SetProperty<T>(ref T field, T value, [CallerMemberName] string name = "")
+        {
+            if (EqualityComparer<T>.Default.Equals(field, value))
+            {
+                return;
+            }
+
+            field = value;
+            NotifyPropertyChanged(name);
+        }
+
+        protected void NotifyPropertyChanged(string name)
+            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackedTreeItemViewModel.cs b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackedTreeItemViewModel.cs
new file mode 100644
index 0000000000000..a11aefa1f07d0
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackedTreeItemViewModel.cs
@@ -0,0 +1,164 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Navigation;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.ValueTracking;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.VisualStudio.Shell;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class ValueTrackedTreeItemViewModel : TreeItemViewModel
+    {
+        private bool _childrenCalculated;
+        private readonly Solution _solution;
+        private readonly IGlyphService _glyphService;
+        private readonly IValueTrackingService _valueTrackingService;
+        private readonly ValueTrackedItem _trackedItem;
+
+        public override bool IsNodeExpanded
+        {
+            get => base.IsNodeExpanded;
+            set
+            {
+                base.IsNodeExpanded = value;
+                CalculateChildren();
+            }
+        }
+
+        public ValueTrackedTreeItemViewModel(
+            ValueTrackedItem trackedItem,
+            Solution solution,
+            ValueTrackingTreeViewModel treeViewModel,
+            IGlyphService glyphService,
+            IValueTrackingService valueTrackingService,
+            IThreadingContext threadingContext,
+            string fileName,
+            ImmutableArray<TreeItemViewModel> children = default)
+            : base(
+                  trackedItem.Span,
+                  trackedItem.SourceText,
+                  trackedItem.DocumentId,
+                  fileName,
+                  trackedItem.Glyph,
+                  trackedItem.ClassifiedSpans,
+                  treeViewModel,
+                  glyphService,
+                  threadingContext,
+                  solution.Workspace,
+                  children: children)
+        {
+
+            _trackedItem = trackedItem;
+            _solution = solution;
+            _glyphService = glyphService;
+            _valueTrackingService = valueTrackingService;
+
+            if (children.IsDefaultOrEmpty)
+            {
+                // Add an empty item so the treeview has an expansion showing to calculate
+                // the actual children of the node
+                ChildItems.Add(EmptyTreeViewItem.Instance);
+
+                ChildItems.CollectionChanged += (s, a) =>
+                {
+                    NotifyPropertyChanged(nameof(ChildItems));
+                };
+            }
+        }
+
+        private void CalculateChildren()
+        {
+            ThreadHelper.ThrowIfNotOnUIThread();
+
+            if (_childrenCalculated || IsLoading)
+            {
+                return;
+            }
+
+            TreeViewModel.LoadingCount++;
+            IsLoading = true;
+            ChildItems.Clear();
+
+            var computingItem = new ComputingTreeViewItem();
+            ChildItems.Add(computingItem);
+
+            System.Threading.Tasks.Task.Run(async () =>
+            {
+                try
+                {
+                    var children = await CalculateChildrenAsync(ThreadingContext.DisposalToken).ConfigureAwait(false);
+
+                    await ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
+
+                    ChildItems.Clear();
+
+                    foreach (var child in children)
+                    {
+                        ChildItems.Add(child);
+                    }
+                }
+                finally
+                {
+                    await ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
+                    TreeViewModel.LoadingCount--;
+                    _childrenCalculated = true;
+                    IsLoading = false;
+                }
+            }, ThreadingContext.DisposalToken);
+        }
+
+        public override void NavigateTo()
+        {
+            var navigationService = Workspace.Services.GetService<IDocumentNavigationService>();
+            if (navigationService is null)
+            {
+                return;
+            }
+
+            // While navigating do not activate the tab, which will change focus from the tool window
+            var options = Workspace.Options
+                .WithChangedOption(new OptionKey(NavigationOptions.PreferProvisionalTab), true)
+                .WithChangedOption(new OptionKey(NavigationOptions.ActivateTab), false);
+
+            navigationService.TryNavigateToSpan(Workspace, DocumentId, _trackedItem.Span, options, ThreadingContext.DisposalToken);
+        }
+
+        private async Task<ImmutableArray<TreeItemViewModel>> CalculateChildrenAsync(CancellationToken cancellationToken)
+        {
+            var valueTrackedItems = await _valueTrackingService.TrackValueSourceAsync(
+                _solution,
+                _trackedItem,
+                cancellationToken).ConfigureAwait(false);
+
+            var builder = ImmutableArray.CreateBuilder<TreeItemViewModel>(valueTrackedItems.Length);
+
+            foreach (var valueTrackedItem in valueTrackedItems)
+            {
+                var document = _solution.GetRequiredDocument(valueTrackedItem.DocumentId);
+                var fileName = document.FilePath ?? document.Name;
+
+                builder.Add(new ValueTrackedTreeItemViewModel(
+                    valueTrackedItem,
+                    _solution,
+                    TreeViewModel,
+                    _glyphService,
+                    _valueTrackingService,
+                    ThreadingContext,
+                    fileName
+                    ));
+            }
+
+            return builder.ToImmutableArray();
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingCommandHandler.cs b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingCommandHandler.cs
new file mode 100644
index 0000000000000..58953daae4ea4
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingCommandHandler.cs
@@ -0,0 +1,271 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.ComponentModel.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Internal.Log;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.ValueTracking;
+using Microsoft.VisualStudio.Commanding;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.LanguageServices.Setup;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+using Roslyn.Utilities;
+using IAsyncServiceProvider = Microsoft.VisualStudio.Shell.IAsyncServiceProvider;
+using Task = System.Threading.Tasks.Task;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    [Export(typeof(ICommandHandler))]
+    [ContentType(ContentTypeNames.RoslynContentType)]
+    [Name(PredefinedCommandHandlerNames.ShowValueTracking)]
+    internal class ValueTrackingCommandHandler : ICommandHandler<ValueTrackingEditorCommandArgs>
+    {
+        private readonly IAsyncServiceProvider _serviceProvider;
+        private readonly IThreadingContext _threadingContext;
+        private readonly ClassificationTypeMap _typeMap;
+        private readonly IClassificationFormatMapService _classificationFormatMapService;
+        private readonly IGlyphService _glyphService;
+        private readonly IEditorFormatMapService _formatMapService;
+        private RoslynPackage? _roslynPackage;
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public ValueTrackingCommandHandler(
+            SVsServiceProvider serviceProvider,
+            IThreadingContext threadingContext,
+            ClassificationTypeMap typeMap,
+            IClassificationFormatMapService classificationFormatMapService,
+            IGlyphService glyphService,
+            IEditorFormatMapService formatMapService)
+        {
+            _serviceProvider = (IAsyncServiceProvider)serviceProvider;
+            _threadingContext = threadingContext;
+            _typeMap = typeMap;
+            _classificationFormatMapService = classificationFormatMapService;
+            _glyphService = glyphService;
+            _formatMapService = formatMapService;
+        }
+
+        public string DisplayName => "Go to value tracking";
+
+        public CommandState GetCommandState(ValueTrackingEditorCommandArgs args)
+            => CommandState.Available;
+
+        public bool ExecuteCommand(ValueTrackingEditorCommandArgs args, CommandExecutionContext executionContext)
+        {
+            using var logger = Logger.LogBlock(FunctionId.ValueTracking_Command, CancellationToken.None, LogLevel.Information);
+
+            var cancellationToken = executionContext.OperationContext.UserCancellationToken;
+            var caretPosition = args.TextView.GetCaretPoint(args.SubjectBuffer);
+            if (!caretPosition.HasValue)
+            {
+                return false;
+            }
+
+            var textSpan = new TextSpan(caretPosition.Value.Position, 0);
+            var sourceTextContainer = args.SubjectBuffer.AsTextContainer();
+            var document = sourceTextContainer.GetOpenDocumentInCurrentContext();
+            if (document is null)
+            {
+                return false;
+            }
+
+            _threadingContext.JoinableTaskFactory.RunAsync(async () =>
+                {
+                    var selectedSymbol = await GetSelectedSymbolAsync(textSpan, document, cancellationToken).ConfigureAwait(false);
+                    if (selectedSymbol is null)
+                    {
+                        // TODO: Show error dialog
+                        return;
+                    }
+
+                    var syntaxTree = document.GetRequiredSyntaxTreeSynchronously(cancellationToken);
+                    var location = Location.Create(syntaxTree, textSpan);
+
+                    await ShowToolWindowAsync(args.TextView, selectedSymbol, location, document.Project.Solution, cancellationToken).ConfigureAwait(false);
+                });
+
+            return true;
+        }
+
+        private static async Task<ISymbol?> GetSelectedSymbolAsync(TextSpan textSpan, Document document, CancellationToken cancellationToken)
+        {
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var selectedNode = root.FindNode(textSpan);
+            if (selectedNode is null)
+            {
+                return null;
+            }
+
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var selectedSymbol =
+                semanticModel.GetSymbolInfo(selectedNode, cancellationToken).Symbol
+                ?? semanticModel.GetDeclaredSymbol(selectedNode, cancellationToken);
+
+            if (selectedSymbol is null)
+            {
+                return null;
+            }
+
+            return selectedSymbol switch
+            {
+                ILocalSymbol
+                or IPropertySymbol { SetMethod: not null }
+                or IFieldSymbol { IsReadOnly: false }
+                or IEventSymbol
+                or IParameterSymbol
+                => selectedSymbol,
+
+                _ => null
+            };
+        }
+
+        private async Task ShowToolWindowAsync(ITextView textView, ISymbol selectedSymbol, Location location, Solution solution, CancellationToken cancellationToken)
+        {
+            var item = await ValueTrackedItem.TryCreateAsync(solution, location, selectedSymbol, cancellationToken: cancellationToken).ConfigureAwait(false);
+            if (item is null)
+            {
+                return;
+            }
+
+            var toolWindow = await GetOrCreateToolWindowAsync(textView, cancellationToken).ConfigureAwait(false);
+            if (toolWindow?.ViewModel is null)
+            {
+                return;
+            }
+
+            var valueTrackingService = solution.Workspace.Services.GetRequiredService<IValueTrackingService>();
+            var classificationFormatMap = _classificationFormatMapService.GetClassificationFormatMap(textView);
+
+            var childItems = await valueTrackingService.TrackValueSourceAsync(solution, item, cancellationToken).ConfigureAwait(false);
+            var childViewModels = childItems.SelectAsArray(child => CreateViewModel(child));
+
+            RoslynDebug.AssertNotNull(location.SourceTree);
+            var document = solution.GetRequiredDocument(location.SourceTree);
+
+            var sourceText = await location.SourceTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(document, location.SourceSpan, cancellationToken).ConfigureAwait(false);
+            var classificationResult = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(documentSpan, cancellationToken).ConfigureAwait(false);
+
+            var root = new TreeItemViewModel(
+                location.SourceSpan,
+                sourceText,
+                document.Id,
+                document.FilePath ?? document.Name,
+                selectedSymbol.GetGlyph(),
+                classificationResult.ClassifiedSpans,
+                toolWindow.ViewModel,
+                _glyphService,
+                _threadingContext,
+                solution.Workspace,
+                children: childViewModels);
+
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            toolWindow.ViewModel.Roots.Clear();
+            toolWindow.ViewModel.Roots.Add(root);
+
+            await ShowToolWindowAsync(cancellationToken).ConfigureAwait(true);
+
+            TreeItemViewModel CreateViewModel(ValueTrackedItem valueTrackedItem, ImmutableArray<TreeItemViewModel> children = default)
+            {
+                var document = solution.GetRequiredDocument(valueTrackedItem.DocumentId);
+                var fileName = document.FilePath ?? document.Name;
+
+                return new ValueTrackedTreeItemViewModel(
+                   valueTrackedItem,
+                   solution,
+                   toolWindow.ViewModel,
+                   _glyphService,
+                   valueTrackingService,
+                   _threadingContext,
+                   fileName,
+                   children);
+            }
+        }
+
+        private async Task ShowToolWindowAsync(CancellationToken cancellationToken)
+        {
+            var roslynPackage = await TryGetRoslynPackageAsync(cancellationToken).ConfigureAwait(false);
+            Contract.ThrowIfNull(roslynPackage);
+
+            await roslynPackage.ShowToolWindowAsync(
+                    typeof(ValueTrackingToolWindow),
+                    0,
+                    true,
+                    roslynPackage.DisposalToken).ConfigureAwait(false);
+        }
+
+        private async Task<ValueTrackingToolWindow?> GetOrCreateToolWindowAsync(ITextView textView, CancellationToken cancellationToken)
+        {
+            var roslynPackage = await TryGetRoslynPackageAsync(cancellationToken).ConfigureAwait(false);
+            if (roslynPackage is null)
+            {
+                return null;
+            }
+
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            if (ValueTrackingToolWindow.Instance is null)
+            {
+                var factory = roslynPackage.GetAsyncToolWindowFactory(Guids.ValueTrackingToolWindowId);
+
+                var viewModel = new ValueTrackingTreeViewModel(_classificationFormatMapService.GetClassificationFormatMap(textView), _typeMap, _formatMapService);
+
+                factory.CreateToolWindow(Guids.ValueTrackingToolWindowId, 0, viewModel);
+                await factory.InitializeToolWindowAsync(Guids.ValueTrackingToolWindowId, 0);
+
+                // FindWindowPaneAsync creates an instance if it does not exist
+                ValueTrackingToolWindow.Instance = (ValueTrackingToolWindow)await roslynPackage.FindWindowPaneAsync(
+                    typeof(ValueTrackingToolWindow),
+                    0,
+                    true,
+                    roslynPackage.DisposalToken).ConfigureAwait(false);
+            }
+
+            // This can happen if the tool window was initialized outside of this command handler. The ViewModel 
+            // still needs to be initialized but had no necessary context. Provide that context now in the command handler.
+            if (ValueTrackingToolWindow.Instance.ViewModel is null)
+            {
+                ValueTrackingToolWindow.Instance.ViewModel = new ValueTrackingTreeViewModel(_classificationFormatMapService.GetClassificationFormatMap(textView), _typeMap, _formatMapService);
+            }
+
+            return ValueTrackingToolWindow.Instance;
+        }
+
+        private async ValueTask<RoslynPackage?> TryGetRoslynPackageAsync(CancellationToken cancellationToken)
+        {
+            if (_roslynPackage is null)
+            {
+                await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+                var shell = (IVsShell7?)await _serviceProvider.GetServiceAsync(typeof(SVsShell)).ConfigureAwait(true);
+                Assumes.Present(shell);
+                await shell.LoadPackageAsync(typeof(RoslynPackage).GUID);
+
+                if (ErrorHandler.Succeeded(((IVsShell)shell).IsPackageLoaded(typeof(RoslynPackage).GUID, out var package)))
+                {
+                    _roslynPackage = (RoslynPackage)package;
+                }
+            }
+
+            return _roslynPackage;
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingEditorCommandArgs.cs b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingEditorCommandArgs.cs
new file mode 100644
index 0000000000000..13c4e55145669
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingEditorCommandArgs.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Editor.Commanding;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class ValueTrackingEditorCommandArgs : EditorCommandArgs
+    {
+        public ValueTrackingEditorCommandArgs(ITextView textView, ITextBuffer subjectBuffer) : base(textView, subjectBuffer)
+        {
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingToolWindow.cs b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingToolWindow.cs
new file mode 100644
index 0000000000000..c47b9d092cc54
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingToolWindow.cs
@@ -0,0 +1,81 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using System.Windows.Controls;
+using System.Runtime.InteropServices;
+using Microsoft.VisualStudio.Shell;
+using Roslyn.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    [Guid(Guids.ValueTrackingToolWindowIdString)]
+    internal class ValueTrackingToolWindow : ToolWindowPane
+    {
+        private readonly Grid _rootGrid = new();
+
+        public static ValueTrackingToolWindow? Instance { get; set; }
+
+        private ValueTrackingTreeViewModel? _viewModel;
+        public ValueTrackingTreeViewModel? ViewModel
+        {
+            get => _viewModel;
+            set
+            {
+                if (value is null)
+                {
+                    throw new ArgumentNullException(nameof(ViewModel));
+                }
+
+                _viewModel = value;
+                _rootGrid.Children.Clear();
+                _rootGrid.Children.Add(new ValueTrackingTree(_viewModel));
+            }
+        }
+
+        /// <summary>
+        /// This paramterless constructor is used when
+        /// the tool window is initialized on open without any
+        /// context. If the tool window is left open across shutdown/restart
+        /// of VS for example, then this gets called. 
+        /// </summary>
+        public ValueTrackingToolWindow() : base(null)
+        {
+            Caption = ServicesVSResources.Value_Tracking;
+
+            _rootGrid.Children.Add(new TextBlock()
+            {
+                Text = ServicesVSResources.Select_an_appropriate_symbol_to_start_value_tracking
+            });
+
+            Content = _rootGrid;
+        }
+
+        public ValueTrackingToolWindow(ValueTrackingTreeViewModel viewModel)
+            : base(null)
+        {
+            Caption = ServicesVSResources.Value_Tracking;
+            Content = _rootGrid;
+            ViewModel = viewModel;
+        }
+
+        public TreeItemViewModel? Root
+        {
+            get => ViewModel?.Roots.Single();
+            set
+            {
+                if (value is null)
+                {
+                    return;
+                }
+
+                Contract.ThrowIfNull(ViewModel);
+
+                ViewModel.Roots.Clear();
+                ViewModel.Roots.Add(value);
+            }
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTree.xaml b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTree.xaml
new file mode 100644
index 0000000000000..88087b3356b33
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTree.xaml
@@ -0,0 +1,99 @@
+<UserControl x:Class="Microsoft.VisualStudio.LanguageServices.ValueTracking.ValueTrackingTree"
+             x:ClassModifier="internal"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:Microsoft.VisualStudio.LanguageServices.ValueTracking"
+             mc:Ignorable="d" 
+             xmlns:vs="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.15.0"
+             d:DesignHeight="450" d:DesignWidth="800"
+             x:Name="control">
+
+    <UserControl.Resources>
+        <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" />
+    </UserControl.Resources>
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition />
+            <ColumnDefinition Width="Auto" />
+            <ColumnDefinition />
+        </Grid.ColumnDefinitions>
+
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition />
+        </Grid.RowDefinitions>
+
+        <ProgressBar
+            Grid.Row="0"
+            Grid.ColumnSpan="3"
+            Grid.Column="0"
+            IsIndeterminate="True"
+            Panel.ZIndex="10000"
+            Minimum="0"
+            Maximum="100"
+            Height="2"
+            Visibility="{Binding IsLoading, Mode=OneWay, Converter={StaticResource BooleanToVisibilityConverter}}"
+            Foreground="{DynamicResource {x:Static vs:ProgressBarColors.IndicatorFillBrushKey}}"
+            Background="{DynamicResource {x:Static vs:ProgressBarColors.BackgroundBrushKey}}" />
+        
+        <ScrollViewer Grid.Row="1" Grid.Column="0" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto">
+            <TreeView  x:Name="ValueTrackingTreeView" ItemsSource="{Binding Roots}" BorderThickness="0" PreviewKeyDown="ValueTrackingTreeView_PreviewKeyDown" MouseDown="ValueTrackingTreeView_MouseClickPreview" PreviewMouseDoubleClick="ValueTrackingTreeView_MouseClickPreview">
+                <TreeView.ItemContainerStyle>
+                    <Style TargetType="{x:Type TreeViewItem}">
+                        <Setter Property="IsExpanded" Value="{Binding IsNodeExpanded, Mode=TwoWay}" />
+                        <Setter Property="IsSelected" Value="{Binding IsNodeSelected, Mode=TwoWay}" />
+                    </Style>
+                </TreeView.ItemContainerStyle>
+                <TreeView.Resources>
+                    <HierarchicalDataTemplate DataType="{x:Type local:TreeItemViewModel}" ItemsSource="{Binding ChildItems}">
+                        <StackPanel Orientation="Horizontal">
+                            <Image Source="{Binding GlyphImage}" />
+                            <local:BindableTextBlock InlineCollection="{Binding Inlines}" Margin="0 0 5 0" />
+                        </StackPanel>
+                    </HierarchicalDataTemplate>
+                    <DataTemplate DataType="{x:Type local:EmptyTreeViewItem}">
+                    </DataTemplate>
+                    <DataTemplate DataType="{x:Type local:ComputingTreeViewItem}">
+                        <StackPanel Orientation="Horizontal">
+                            <vs:ProgressControl Margin="2" HorizontalAlignment="Center" VerticalAlignment="Center">
+                                <vs:ProgressControl.RenderTransform>
+                                    <ScaleTransform ScaleX="0.50" ScaleY="0.50" />
+                                </vs:ProgressControl.RenderTransform>
+                            </vs:ProgressControl>
+                            <TextBlock Text="{Binding Text}" Margin="0 0 5 0" />
+                        </StackPanel>
+                    </DataTemplate>
+                </TreeView.Resources>
+            </TreeView>
+        </ScrollViewer>
+
+        <GridSplitter 
+            Grid.Column="1" 
+            Grid.Row="1"
+            ResizeBehavior="PreviousAndNext"
+            ShowsPreview="true"
+            Width="5" />
+
+        <ScrollViewer Grid.Column="2" Grid.Row="1" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto" HorizontalContentAlignment="Left" HorizontalAlignment="Left">
+            <Grid Visibility="{Binding ShowDetails, Converter={StaticResource BooleanToVisibilityConverter}}" HorizontalAlignment="Left">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="*" />
+                </Grid.ColumnDefinitions>
+
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                </Grid.RowDefinitions>
+
+                <Label Content="File" Grid.Row="0" Grid.Column="0" x:Name="FileNameLabel" />
+                <TextBlock Grid.Row="0" Grid.Column="1" Text="{Binding SelectedItemFile}" x:Name="FileName" AutomationProperties.LabeledBy="{Binding ElementName=FileNameLabel}" VerticalAlignment="Center" />
+
+                <Label Content="Line" Grid.Row="1" Grid.Column="0" x:Name="LineNumberLabel" />
+                <TextBlock  Grid.Row="1" Grid.Column="1" Text="{Binding SelectedItemLine}" x:Name="LineNumber" AutomationProperties.LabeledBy="{Binding ElementName=LineNumberLabel}" VerticalAlignment="Center" />
+            </Grid>
+        </ScrollViewer>
+    </Grid>
+</UserControl>
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTree.xaml.cs b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTree.xaml.cs
new file mode 100644
index 0000000000000..4b35d9a0e61b9
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTree.xaml.cs
@@ -0,0 +1,128 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    /// <summary>
+    /// Interaction logic for ValueTrackingTree.xaml
+    /// </summary>
+    internal partial class ValueTrackingTree : UserControl
+    {
+        public ValueTrackingTree(ValueTrackingTreeViewModel viewModel)
+        {
+            DataContext = viewModel;
+            InitializeComponent();
+        }
+
+        private void ValueTrackingTreeView_PreviewKeyDown(object sender, KeyEventArgs e)
+        {
+            e.Handled = e.Handled || e.Key switch
+            {
+                Key.Down => TrySelectItem(GetNextItem(expandNode: false), navigate: true),
+                Key.Up => TrySelectItem(GetPreviousItem(), navigate: true),
+                Key.F8 => e.KeyboardDevice.Modifiers == ModifierKeys.Shift ? TrySelectItem(GetPreviousItem(), navigate: true) : TrySelectItem(GetNextItem(expandNode: true), navigate: true),
+                Key.Enter => TrySelectItem(ValueTrackingTreeView.SelectedItem as TreeViewItemBase, navigate: true),
+                Key.Right => TrySetExpanded(ValueTrackingTreeView.SelectedItem as TreeViewItemBase, true),
+                Key.Left => TrySetExpanded(ValueTrackingTreeView.SelectedItem as TreeViewItemBase, false),
+                Key.Space => TryToggleExpanded(ValueTrackingTreeView.SelectedItem as TreeViewItemBase),
+                _ => false
+            };
+
+            // Local Functions
+
+            static bool TrySelectItem(TreeViewItemBase? node, bool navigate)
+            {
+                if (node is null)
+                {
+                    return false;
+                }
+
+                SelectItem(node, navigate);
+                return true;
+            }
+
+            static bool TrySetExpanded(TreeViewItemBase? node, bool expanded)
+            {
+                if (node is null)
+                {
+                    return false;
+                }
+
+                node.IsNodeExpanded = expanded;
+                return true;
+            }
+
+            static bool TryToggleExpanded(TreeViewItemBase? node)
+            {
+                return TrySetExpanded(node, node is null ? false : !node.IsNodeExpanded);
+            }
+        }
+
+        private void ValueTrackingTreeView_MouseClickPreview(object sender, MouseButtonEventArgs e)
+        {
+            if (sender is TreeViewItemBase viewModel && e.ChangedButton == MouseButton.Left)
+            {
+                SelectItem(viewModel, true);
+                e.Handled = true;
+            }
+        }
+
+        private static void SelectItem(TreeViewItemBase? item, bool navigate = false)
+        {
+            if (item is null)
+            {
+                return;
+            }
+
+            item.IsNodeSelected = true;
+            if (navigate && item is TreeItemViewModel navigatableItem)
+            {
+                navigatableItem.NavigateTo();
+            }
+        }
+
+        private TreeViewItemBase GetNextItem(bool expandNode)
+        {
+            if (ValueTrackingTreeView.SelectedItem is null)
+            {
+                return (TreeViewItemBase)ValueTrackingTreeView.Items[0];
+            }
+
+            var item = (TreeViewItemBase)ValueTrackingTreeView.SelectedItem;
+
+            if (expandNode)
+            {
+                item.IsNodeExpanded = true;
+            }
+
+            return item.GetNextInTree();
+        }
+
+        private TreeViewItemBase GetPreviousItem()
+        {
+            if (ValueTrackingTreeView.SelectedItem is null)
+            {
+                return (TreeViewItemBase)ValueTrackingTreeView.Items[ValueTrackingTreeView.Items.Count - 1];
+            }
+
+            var item = (TreeViewItemBase)ValueTrackingTreeView.SelectedItem;
+            return item.GetPreviousInTree();
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTreeRootViewModel.cs b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTreeRootViewModel.cs
new file mode 100644
index 0000000000000..7617daec33d9d
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTreeRootViewModel.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class ValueTrackingTreeRootViewModel : TreeViewItemBase
+    {
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTreeViewModel.cs b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTreeViewModel.cs
new file mode 100644
index 0000000000000..7dd7f79e4f368
--- /dev/null
+++ b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingTreeViewModel.cs
@@ -0,0 +1,112 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Windows.Media;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.VisualStudio.Text.Classification;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class ValueTrackingTreeViewModel : INotifyPropertyChanged
+    {
+        private Brush? _highlightBrush;
+        public Brush? HighlightBrush
+        {
+            get => _highlightBrush;
+            set => SetProperty(ref _highlightBrush, value);
+        }
+
+        public IClassificationFormatMap ClassificationFormatMap { get; }
+        public ClassificationTypeMap ClassificationTypeMap { get; }
+        public IEditorFormatMapService FormatMapService { get; }
+        public ObservableCollection<TreeItemViewModel> Roots { get; } = new();
+
+        private TreeItemViewModel? _selectedItem;
+        public TreeItemViewModel? SelectedItem
+        {
+            get => _selectedItem;
+            set => SetProperty(ref _selectedItem, value);
+        }
+
+        private string _selectedItemFile = "";
+        public string SelectedItemFile
+        {
+            get => _selectedItemFile;
+            set => SetProperty(ref _selectedItemFile, value);
+        }
+
+        private int _selectedItemLine;
+        public int SelectedItemLine
+        {
+            get => _selectedItemLine;
+            set => SetProperty(ref _selectedItemLine, value);
+        }
+
+        private bool _isLoading;
+        public bool IsLoading
+        {
+            get => _isLoading;
+            private set => SetProperty(ref _isLoading, value);
+        }
+
+        private int _loadingCount;
+        public int LoadingCount
+        {
+            get => _loadingCount;
+            set => SetProperty(ref _loadingCount, value);
+        }
+
+        public bool ShowDetails => SelectedItem is not null;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public ValueTrackingTreeViewModel(IClassificationFormatMap classificationFormatMap, ClassificationTypeMap classificationTypeMap, IEditorFormatMapService formatMapService)
+        {
+            ClassificationFormatMap = classificationFormatMap;
+            ClassificationTypeMap = classificationTypeMap;
+            FormatMapService = formatMapService;
+
+            var properties = FormatMapService.GetEditorFormatMap("text")
+                                          .GetProperties(ReferenceHighlightTag.TagId);
+
+            HighlightBrush = properties["Background"] as Brush;
+
+            PropertyChanged += Self_PropertyChanged;
+        }
+
+        private void Self_PropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName == nameof(SelectedItem))
+            {
+                SelectedItemFile = SelectedItem?.FileName ?? "";
+                SelectedItemLine = SelectedItem?.LineNumber ?? 0;
+                NotifyPropertyChanged(nameof(ShowDetails));
+            }
+
+            if (e.PropertyName == nameof(LoadingCount))
+            {
+                IsLoading = LoadingCount > 0;
+            }
+        }
+
+        private void SetProperty<T>(ref T field, T value, [CallerMemberName] string name = "")
+        {
+            if (EqualityComparer<T>.Default.Equals(field, value))
+            {
+                return;
+            }
+
+            field = value;
+            NotifyPropertyChanged(name);
+        }
+
+        private void NotifyPropertyChanged(string name)
+            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
+    }
+}
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
index 0e52ac94505e0..68a57fefc19ac 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
@@ -422,6 +422,21 @@
         <target state="translated">Přejít na implementaci</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">Inicializovat Interactive přes projekt</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
index 0519b3914d895..424b0c948aa2f 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
@@ -422,6 +422,21 @@
         <target state="translated">Zur Implementierung wechseln</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">Interaktiv mit dem Projekt initialisieren</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
index ea66b98523deb..7afdf3f06e6af 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
@@ -422,6 +422,21 @@
         <target state="translated">Ir a la implementación</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">Inicializar el elemento interactivo con el proyecto</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
index 9d160e734b01e..1dc3ee642ba0e 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
@@ -422,6 +422,21 @@
         <target state="translated">Accéder à l'implémentation</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">Initialiser Interactive avec le projet</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
index eca0815f79dfd..296cb63ffdb7a 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
@@ -422,6 +422,21 @@
         <target state="translated">Vai all'implementazione</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">Inizializza Interactive con il progetto</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
index c9fd9de0dacc2..f3d8a513cee51 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
@@ -422,6 +422,21 @@
         <target state="translated">実装に移動</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">プロジェクトでインタラクティブを初期化</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
index f46c17cad23dc..db267369fce8b 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
@@ -422,6 +422,21 @@
         <target state="translated">구현으로 이동</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">프로젝트에서 Interactive 초기화</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
index 84daa1c5d3583..cf0051892a3ef 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
@@ -422,6 +422,21 @@
         <target state="translated">Przejdź do implementacji</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">Inicjuj środowisko interaktywne z projektem</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
index 649547a61b334..44e671f80ac66 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
@@ -422,6 +422,21 @@
         <target state="translated">Ir para Implementação</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">Inicializar Interativo com o Projeto</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
index 04c129f151eaa..c9f72d416a7e8 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
@@ -422,6 +422,21 @@
         <target state="translated">Перейти к реализации</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">Инициализировать интерактивное окно с проектом</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
index 5b4ddbcbab5ea..4c467e7672b2f 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
@@ -422,6 +422,21 @@
         <target state="translated">Uygulamaya Git</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">Projeyi Etkileşimli Pencerede Başlat</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
index 5d051cf4b5a87..58d2499edc208 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
@@ -422,6 +422,21 @@
         <target state="translated">转到实现</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">对交互窗口进行项目初始化</target>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
index 96f40643fd380..1e6790f40a30e 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
@@ -422,6 +422,21 @@
         <target state="translated">前往實作</target>
         <note />
       </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|ButtonText">
+        <source>Track Value Source</source>
+        <target state="new">Track Value Source</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|CommandName">
+        <source>ShowValueTrackingCommandName</source>
+        <target state="new">ShowValueTrackingCommandName</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
+        <source>ViewEditorConfigSettings</source>
+        <target state="new">ViewEditorConfigSettings</target>
+        <note />
+      </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
         <source>Initialize Interactive with Project</source>
         <target state="translated">使用專案將 Interactive 初始化</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
index 2002c08bc6807..099d2851e104e 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
@@ -147,6 +147,11 @@
         <target state="translated">Klient jazyka diagnostiky C# nebo Visual Basic</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">Počítají se závislosti...</target>
@@ -242,6 +247,11 @@
         <target state="translated">Aktuální parametr</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">Zakázáno</target>
@@ -377,6 +387,11 @@
         <target state="translated">ID</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">Implementovaní členové</target>
@@ -387,6 +402,11 @@
         <target state="translated">Implementace členů</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">V jiných operátorech</target>
@@ -417,6 +437,11 @@
         <target state="translated">Míra dědičnosti (experimentální)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">Vložené nápovědy (experimentální)</target>
@@ -962,6 +987,11 @@
         <target state="translated">Nastavení hledání</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">Vybrat cíl</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">Zobrazit míru dědičnosti</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">Některé barvy barevného schématu se přepsaly změnami na stránce možností Prostředí &gt; Písma a barvy. Pokud chcete zrušit všechna přizpůsobení, vyberte na stránce Písma a barvy možnost Použít výchozí.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">Hodnota</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">Zde přiřazená hodnota se nikdy nepoužije.</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
index 301bfcadbfd8d..9f1002b4bfab0 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
@@ -147,6 +147,11 @@
         <target state="translated">Client für C#-/Visual Basic-Diagnosesprache</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">Abhängige Objekte werden berechnet...</target>
@@ -242,6 +247,11 @@
         <target state="translated">Aktueller Parameter</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">Deaktiviert</target>
@@ -377,6 +387,11 @@
         <target state="translated">ID</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">Implementierte Member</target>
@@ -387,6 +402,11 @@
         <target state="translated">Member werden implementiert.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">In anderen Operatoren</target>
@@ -417,6 +437,11 @@
         <target state="translated">Vererbungsrand (experimentell)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">Inlinehinweise (experimentell)</target>
@@ -962,6 +987,11 @@
         <target state="translated">Sucheinstellungen</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">Ziel auswählen</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">Vererbungsrand anzeigen</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">Einige Farbschemafarben werden durch Änderungen überschrieben, die auf der Optionsseite "Umgebung" &gt; "Schriftarten und Farben" vorgenommen wurden. Wählen Sie auf der Seite "Schriftarten und Farben" die Option "Standardwerte verwenden" aus, um alle Anpassungen rückgängig zu machen.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">Wert</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">Der hier zugewiesene Wert wird nie verwendet.</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
index 0c45d7110260e..969c9d02e88fd 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
@@ -147,6 +147,11 @@
         <target state="translated">Cliente de lenguaje de diagnóstico de C#/Visual Basic</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">Calculando dependientes...</target>
@@ -242,6 +247,11 @@
         <target state="translated">Parámetro actual</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">Deshabilitado</target>
@@ -377,6 +387,11 @@
         <target state="translated">Id.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">Miembros implementados</target>
@@ -387,6 +402,11 @@
         <target state="translated">Implementando miembros</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">En otros operadores</target>
@@ -417,6 +437,11 @@
         <target state="translated">Margen de herencia (experimental)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">Sugerencias en línea (experimental)</target>
@@ -962,6 +987,11 @@
         <target state="translated">Buscar configuración</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">Seleccionar destino</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">Mostrar margen de herencia</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">Algunos de los colores de la combinación se reemplazan por los cambios realizados en la página de opciones de Entorno &gt; Fuentes y colores. Elija "Usar valores predeterminados" en la página Fuentes y colores para revertir todas las personalizaciones.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">Valor</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">El valor asignado aquí no se usa nunca</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
index 1f65b3053e75c..679fc6a454c49 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
@@ -147,6 +147,11 @@
         <target state="translated">Client de langage de diagnostics C#/Visual Basic</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">Calcul des dépendants...</target>
@@ -242,6 +247,11 @@
         <target state="translated">Paramètre actuel</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">Désactivé</target>
@@ -377,6 +387,11 @@
         <target state="translated">ID</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">Membres implémentés</target>
@@ -387,6 +402,11 @@
         <target state="translated">Implémentation des membres</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">Dans les autres opérateurs</target>
@@ -417,6 +437,11 @@
         <target state="translated">Marge d’héritage (expérimental)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">Indicateurs inline (expérimental)</target>
@@ -962,6 +987,11 @@
         <target state="translated">Paramètres de recherche</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">Sélectionner la destination</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">Afficher la marge d’héritage</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">Certaines couleurs du modèle de couleurs sont substituées à la suite des changements apportés dans la page d'options Environnement &gt; Polices et couleurs. Choisissez Utiliser les valeurs par défaut dans la page Polices et couleurs pour restaurer toutes les personnalisations.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">Valeur</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">La valeur affectée ici n'est jamais utilisée</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
index 0349965882bbd..5248bd7d012ab 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
@@ -147,6 +147,11 @@
         <target state="translated">Client del linguaggio di diagnostica C#/Visual Basic</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">Calcolo dei dipendenti...</target>
@@ -242,6 +247,11 @@
         <target state="translated">Parametro corrente</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">Disabilitato</target>
@@ -377,6 +387,11 @@
         <target state="translated">ID</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">Membri implementati</target>
@@ -387,6 +402,11 @@
         <target state="translated">Membri di implementazione</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">In altri operatori</target>
@@ -417,6 +437,11 @@
         <target state="translated">Margine ereditarietà (sperimentale)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">Suggerimenti inline (sperimentale)</target>
@@ -962,6 +987,11 @@
         <target state="translated">Impostazioni di ricerca</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">Seleziona destinazione</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">Mostra margine di ereditarietà</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">Alcuni colori della combinazione colori sono sostituiti dalle modifiche apportate nella pagina di opzioni Ambiente &gt; Tipi di carattere e colori. Scegliere `Usa impostazioni predefinite` nella pagina Tipi di carattere e colori per ripristinare tutte le personalizzazioni.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">Valore</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">Il valore assegnato qui non viene mai usato</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
index 23f9994b62188..9ebdfc4fada3b 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
@@ -147,6 +147,11 @@
         <target state="translated">C#/Visual Basic 診断言語クライアント</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">依存を計算しています...</target>
@@ -242,6 +247,11 @@
         <target state="translated">現在のパラメーター</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">無効</target>
@@ -377,6 +387,11 @@
         <target state="translated">ID</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">実装されたメンバー</target>
@@ -387,6 +402,11 @@
         <target state="translated">メンバーを実装中</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">その他の演算子内で</target>
@@ -417,6 +437,11 @@
         <target state="translated">継承の余白 (試験段階)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">インラインのヒント (試験段階)</target>
@@ -962,6 +987,11 @@
         <target state="translated">検索設定</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">宛先の選択</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">継承の余白を表示する</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">一部の配色パターンの色は、[環境] &gt; [フォントおよび色] オプション ページで行われた変更によって上書きされます。[フォントおよび色] オプション ページで [既定値を使用] を選択すると、すべてのカスタマイズが元に戻ります。</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">値</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">ここで割り当てた値は一度も使用されません</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
index ca4cc9445efba..5517b47a90ea3 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
@@ -147,6 +147,11 @@
         <target state="translated">C#/Visual Basic 진단 언어 클라이언트</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">종속 항목을 계산하는 중...</target>
@@ -242,6 +247,11 @@
         <target state="translated">현재 매개 변수</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">사용 안 함</target>
@@ -377,6 +387,11 @@
         <target state="translated">ID</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">구현된 구성원</target>
@@ -387,6 +402,11 @@
         <target state="translated">구성원을 구현하는 중</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">기타 연산자</target>
@@ -417,6 +437,11 @@
         <target state="translated">상속 여백(실험용)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">인라인 힌트(실험적)</target>
@@ -962,6 +987,11 @@
         <target state="translated">검색 설정</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">대상 선택</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">상속 여백 표시</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">색 구성표의 일부 색이 [환경] &gt; [글꼴 및 색] 옵션 페이지에서 변경한 내용에 따라 재정의됩니다. 모든 사용자 지정을 되돌리려면 [글꼴 및 색] 페이지에서 '기본값 사용'을 선택하세요.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">값</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">여기에 할당된 값은 사용되지 않습니다.</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
index aeb7bee13c4ad..a88cbdc00479b 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
@@ -147,6 +147,11 @@
         <target state="translated">Klient języka diagnostyki języka C#/Visual Basic</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">Obliczanie elementów zależnych...</target>
@@ -242,6 +247,11 @@
         <target state="translated">Bieżący parametr</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">Wyłączone</target>
@@ -377,6 +387,11 @@
         <target state="translated">Identyfikator</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">Zaimplementowane składowe</target>
@@ -387,6 +402,11 @@
         <target state="translated">Implementowanie składowych</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">W innych operatorach</target>
@@ -417,6 +437,11 @@
         <target state="translated">Margines dziedziczenia (eksperymentalny)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">Wskazówki w tekście (eksperymentalne)</target>
@@ -962,6 +987,11 @@
         <target state="translated">Ustawienia wyszukiwania</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">Wybierz miejsce docelowe</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">Pokaż margines dziedziczenia</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">Niektóre kolory w schemacie kolorów są przesłaniane przez zmiany wprowadzone na stronie opcji Środowisko &gt; Czcionki i kolory. Wybierz pozycję „Użyj ustawień domyślnych” na stronie Czcionki i kolory, aby wycofać wszystkie dostosowania.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">Wartość</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">Przypisana tu wartość nigdy nie jest używana</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
index f62f1065ba862..631be6dc09509 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
@@ -147,6 +147,11 @@
         <target state="translated">Cliente da Linguagem de Diagnóstico C#/Visual Basic</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">Calculando dependentes...</target>
@@ -242,6 +247,11 @@
         <target state="translated">Parâmetro atual</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">Desabilitado</target>
@@ -377,6 +387,11 @@
         <target state="translated">ID</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">Membros implementados</target>
@@ -387,6 +402,11 @@
         <target state="translated">Implementando membros</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">Em outros operadores</target>
@@ -417,6 +437,11 @@
         <target state="translated">Margem de Herança (experimental)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">Dicas Embutidas (experimental)</target>
@@ -962,6 +987,11 @@
         <target state="translated">Pesquisar as Configurações</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">Selecionar destino</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">Mostrar margem de herança</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">Algumas cores do esquema de cores estão sendo substituídas pelas alterações feitas na página de Ambiente &gt; Opções de Fontes e Cores. Escolha 'Usar Padrões' na página Fontes e Cores para reverter todas as personalizações.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">Valor</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">O valor atribuído aqui nunca é usado</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
index c7e53a7d54069..43e37e7fb7556 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
@@ -147,6 +147,11 @@
         <target state="translated">Языковой клиент диагностики C#/Visual Basic</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">Вычисление зависимостей…</target>
@@ -242,6 +247,11 @@
         <target state="translated">Текущий параметр</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">Отключено</target>
@@ -377,6 +387,11 @@
         <target state="translated">ИД</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">Реализованные элементы</target>
@@ -387,6 +402,11 @@
         <target state="translated">Реализация элементов</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">В других операторах</target>
@@ -417,6 +437,11 @@
         <target state="translated">Граница наследования (экспериментальная)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">Встроенные подсказки (экспериментальная функция)</target>
@@ -962,6 +987,11 @@
         <target state="translated">Параметры поиска</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">Выбрать место назначения</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">Показать границу наследования</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">Некоторые цвета цветовой схемы переопределяются изменениями, сделанными на странице "Среда" &gt; "Шрифты и цвета". Выберите "Использовать значения по умолчанию" на странице "Шрифты и цвета", чтобы отменить все настройки.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">Значение</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">Заданное здесь значение не используется.</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
index f6e7d482a1cdd..2d6bb68bb0380 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
@@ -147,6 +147,11 @@
         <target state="translated">C#/Visual Basic Tanılama Dili İstemcisi</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">Bağımlılar hesaplanıyor...</target>
@@ -242,6 +247,11 @@
         <target state="translated">Geçerli parametre</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">Devre dışı</target>
@@ -377,6 +387,11 @@
         <target state="translated">Kimlik</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">Uygulanan üyeler</target>
@@ -387,6 +402,11 @@
         <target state="translated">Üyeleri uygulama</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">Diğer işleçlerde</target>
@@ -417,6 +437,11 @@
         <target state="translated">Devralma Marjı (deneysel)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">Satır İçi İpuçları (deneysel)</target>
@@ -962,6 +987,11 @@
         <target state="translated">Arama Ayarları</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">Hedef seçin</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">Devralma boşluğunu göster</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">Bazı renk düzeni renkleri, Ortam &gt; Yazı Tipleri ve Renkler seçenek sayfasında yapılan değişiklikler tarafından geçersiz kılınıyor. Tüm özelleştirmeleri geri döndürmek için Yazı Tipleri ve Renkler sayfasında `Varsayılanları Kullan` seçeneğini belirleyin.</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">Değer</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">Burada atanan değer hiçbir zaman kullanılmadı</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
index 793a652ff626f..3496d40d78a79 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
@@ -147,6 +147,11 @@
         <target state="translated">C#/Visual Basic 语言服务器客户端</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">正在计算依赖项...</target>
@@ -242,6 +247,11 @@
         <target state="translated">当前参数</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">已禁用</target>
@@ -377,6 +387,11 @@
         <target state="translated">ID</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">实现的成员</target>
@@ -387,6 +402,11 @@
         <target state="translated">正在实现成员</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">在其他运算符中</target>
@@ -417,6 +437,11 @@
         <target state="translated">继承边距(实验性)</target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">内联提示(实验性)</target>
@@ -962,6 +987,11 @@
         <target state="translated">搜索设置</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">选择目标</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">显示继承边距</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">在“环境”&gt;“字体和颜色”选项页中所做的更改将替代某些配色方案颜色。在“字体和颜色”页中选择“使用默认值”，还原所有自定义项。</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">值</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">此处分配的值从未使用过</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
index 3da8a86c54954..aa3dee1116470 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
@@ -147,6 +147,11 @@
         <target state="translated">C#/Visual Basic 診斷語言用戶端</target>
         <note />
       </trans-unit>
+      <trans-unit id="Calculating">
+        <source>Calculating...</source>
+        <target state="new">Calculating...</target>
+        <note>Used in UI to represent progress in the context of loading items. </note>
+      </trans-unit>
       <trans-unit id="Calculating_dependents">
         <source>Calculating dependents...</source>
         <target state="translated">正在計算相依項...</target>
@@ -242,6 +247,11 @@
         <target state="translated">目前的參數</target>
         <note />
       </trans-unit>
+      <trans-unit id="Derived_types">
+        <source>Derived types</source>
+        <target state="new">Derived types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Disabled">
         <source>Disabled</source>
         <target state="translated">已停用</target>
@@ -377,6 +387,11 @@
         <target state="translated">識別碼</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implemented_interfaces">
+        <source>Implemented interfaces</source>
+        <target state="new">Implemented interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Implemented_members">
         <source>Implemented members</source>
         <target state="translated">已實作的成員</target>
@@ -387,6 +402,11 @@
         <target state="translated">實作成員</target>
         <note />
       </trans-unit>
+      <trans-unit id="Implementing_types">
+        <source>Implementing types</source>
+        <target state="new">Implementing types</target>
+        <note />
+      </trans-unit>
       <trans-unit id="In_other_operators">
         <source>In other operators</source>
         <target state="translated">其他運算子中</target>
@@ -417,6 +437,11 @@
         <target state="translated">繼承邊界 (實驗性) </target>
         <note />
       </trans-unit>
+      <trans-unit id="Inherited_interfaces">
+        <source>Inherited interfaces</source>
+        <target state="new">Inherited interfaces</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Inline_Hints_experimental">
         <source>Inline Hints (experimental)</source>
         <target state="translated">內嵌提示 (實驗性)</target>
@@ -962,6 +987,11 @@
         <target state="translated">搜尋設定</target>
         <note />
       </trans-unit>
+      <trans-unit id="Select_an_appropriate_symbol_to_start_value_tracking">
+        <source>Select an appropriate symbol to start value tracking</source>
+        <target state="new">Select an appropriate symbol to start value tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Select_destination">
         <source>Select destination</source>
         <target state="translated">選取目的地</target>
@@ -1037,6 +1067,11 @@
         <target state="translated">顯示繼承邊界</target>
         <note />
       </trans-unit>
+      <trans-unit id="Skip_analyzers_for_implicitly_triggered_builds">
+        <source>Skip analyzers for implicitly triggered builds</source>
+        <target state="new">Skip analyzers for implicitly triggered builds</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Some_color_scheme_colors_are_being_overridden_by_changes_made_in_the_Environment_Fonts_and_Colors_options_page_Choose_Use_Defaults_in_the_Fonts_and_Colors_page_to_revert_all_customizations">
         <source>Some color scheme colors are being overridden by changes made in the Environment &gt; Fonts and Colors options page. Choose `Use Defaults` in the Fonts and Colors page to revert all customizations.</source>
         <target state="translated">[環境] &gt; [字型和色彩選項] 頁面中所做的變更覆寫了某些色彩配置的色彩。請選擇 [字型和色彩] 頁面中的 [使用預設] 來還原所有自訂。</target>
@@ -1172,6 +1207,11 @@
         <target state="translated">值</target>
         <note />
       </trans-unit>
+      <trans-unit id="Value_Tracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note>Title of the "Value Tracking" tool window. "Value" is the variable/symbol and "Tracking" is the action the tool is doing to follow where the value can originate from.</note>
+      </trans-unit>
       <trans-unit id="Value_assigned_here_is_never_used">
         <source>Value assigned here is never used</source>
         <target state="translated">這裡指派的值從未使用過</target>
diff --git a/src/VisualStudio/Core/Impl/CodeModel/CodeModelState.cs b/src/VisualStudio/Core/Impl/CodeModel/CodeModelState.cs
index 653f5f78d8f3b..f1771f36fcc1a 100644
--- a/src/VisualStudio/Core/Impl/CodeModel/CodeModelState.cs
+++ b/src/VisualStudio/Core/Impl/CodeModel/CodeModelState.cs
@@ -38,6 +38,8 @@ public CodeModelState(
             Debug.Assert(languageServices != null);
             Debug.Assert(workspace != null);
 
+            // ⚠ This code runs on the main thread. Language services accessed here should be preloaded in
+            // ProjectCodemodelFactory to avoid blocking MEF operations.
             this.ThreadingContext = threadingContext;
             this.ServiceProvider = serviceProvider;
             this.CodeModelService = languageServices.GetService<ICodeModelService>();
diff --git a/src/VisualStudio/Core/Impl/CodeModel/ProjectCodeModelFactory.cs b/src/VisualStudio/Core/Impl/CodeModel/ProjectCodeModelFactory.cs
index 3d679fbd43688..1a545d92168cc 100644
--- a/src/VisualStudio/Core/Impl/CodeModel/ProjectCodeModelFactory.cs
+++ b/src/VisualStudio/Core/Impl/CodeModel/ProjectCodeModelFactory.cs
@@ -7,15 +7,18 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.ComponentModel.Composition;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
-using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Threading;
 using Roslyn.Utilities;
 using Task = System.Threading.Tasks.Task;
 
@@ -53,7 +56,7 @@ public ProjectCodeModelFactory(
             // for the same documents.  Once enough time has passed, take the documents that were changed and run
             // through them, firing their latest events.
             _documentsToFireEventsFor = new AsyncBatchingWorkQueue<DocumentId>(
-                TimeSpan.FromMilliseconds(visualStudioWorkspace.Options.GetOption(InternalSolutionCrawlerOptions.AllFilesWorkerBackOffTimeSpanInMS)),
+                InternalSolutionCrawlerOptions.AllFilesWorkerBackOffTimeSpan,
                 ProcessNextDocumentBatchAsync,
                 // We only care about unique doc-ids, so pass in this comparer to collapse streams of changes for a
                 // single document down to one notification.
@@ -66,7 +69,7 @@ public ProjectCodeModelFactory(
 
         internal IAsynchronousOperationListener Listener { get; }
 
-        private async Task ProcessNextDocumentBatchAsync(
+        private async ValueTask ProcessNextDocumentBatchAsync(
             ImmutableArray<DocumentId> documentIds, CancellationToken cancellationToken)
         {
             // This logic preserves the previous behavior we had with IForegroundNotificationService.
@@ -76,6 +79,27 @@ private async Task ProcessNextDocumentBatchAsync(
             const int MaxTimeSlice = 15;
             var delayBetweenProcessing = TimeSpan.FromMilliseconds(50);
 
+            Debug.Assert(!_threadingContext.JoinableTaskContext.IsOnMainThread, "The following context switch is not expected to cause runtime overhead.");
+            await TaskScheduler.Default;
+
+            // Ensure MEF services used by the code model are initially obtained on a background thread.
+            // This code avoids allocations where possible.
+            // https://github.com/dotnet/roslyn/issues/54159
+            string? previousLanguage = null;
+            foreach (var (_, projectState) in _visualStudioWorkspace.CurrentSolution.State.ProjectStates)
+            {
+                if (projectState.Language == previousLanguage)
+                {
+                    // Avoid duplicate calls if the language did not change
+                    continue;
+                }
+
+                previousLanguage = projectState.Language;
+                projectState.LanguageServices.GetService<ICodeModelService>();
+                projectState.LanguageServices.GetService<ISyntaxFactsService>();
+                projectState.LanguageServices.GetService<ICodeGenerationService>();
+            }
+
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             var stopwatch = SharedStopwatch.StartNew();
diff --git a/src/VisualStudio/Core/Impl/ProjectSystem/CPS/TempPECompiler.cs b/src/VisualStudio/Core/Impl/ProjectSystem/CPS/TempPECompiler.cs
index e1b9ee9d11ab9..5d07e889d16a4 100644
--- a/src/VisualStudio/Core/Impl/ProjectSystem/CPS/TempPECompiler.cs
+++ b/src/VisualStudio/Core/Impl/ProjectSystem/CPS/TempPECompiler.cs
@@ -33,6 +33,7 @@ public async Task<bool> CompileAsync(IWorkspaceProjectContext context, string ou
             {
                 throw new ArgumentException(nameof(filesToInclude), "Must specify some files to compile.");
             }
+
             if (outputFileName == null)
             {
                 throw new ArgumentException(nameof(outputFileName), "Must specify an output file name.");
diff --git a/src/VisualStudio/Core/Test/CommonControls/MemberSelectionViewModelTests.vb b/src/VisualStudio/Core/Test/CommonControls/MemberSelectionViewModelTests.vb
index dc9bb381a0551..453be35d609ec 100644
--- a/src/VisualStudio/Core/Test/CommonControls/MemberSelectionViewModelTests.vb
+++ b/src/VisualStudio/Core/Test/CommonControls/MemberSelectionViewModelTests.vb
@@ -159,6 +159,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.CommonControls
             If (member Is Nothing) Then
                 Assert.True(False, $"No member called {name} found")
             End If
+
             Return member
         End Function
 
diff --git a/src/VisualStudio/Core/Test/DebuggerIntelliSense/CSharpDebuggerIntellisenseTests.vb b/src/VisualStudio/Core/Test/DebuggerIntelliSense/CSharpDebuggerIntellisenseTests.vb
index db75eb5203961..930f0e025a77e 100644
--- a/src/VisualStudio/Core/Test/DebuggerIntelliSense/CSharpDebuggerIntellisenseTests.vb
+++ b/src/VisualStudio/Core/Test/DebuggerIntelliSense/CSharpDebuggerIntellisenseTests.vb
@@ -145,6 +145,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.DebuggerIntelliSense
                 For i As Integer = 0 To 7
                     state.SendBackspace()
                 Next
+
                 Await state.AssertNoCompletionSession()
 
                 state.SendTypeChars("green")
diff --git a/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb b/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb
index e4fcc5e1edf83..1acc49cc93025 100644
--- a/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb
+++ b/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb
@@ -246,6 +246,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                                                               Assert.Equal(1, diagnostics.Length)
                                                               Assert.Equal(diagnostics(0).Properties(WellKnownDiagnosticPropertyNames.Origin), WellKnownDiagnosticTags.Build)
                                                           End Sub
+
                     source.OnSolutionBuildCompleted()
 
                     Await waiter.ExpeditedWaitAsync()
diff --git a/src/VisualStudio/Core/Test/InheritanceMargin/InheritanceMarginViewModelTests.vb b/src/VisualStudio/Core/Test/InheritanceMargin/InheritanceMarginViewModelTests.vb
index d8c2d3b1bf24c..072ef91f7774d 100644
--- a/src/VisualStudio/Core/Test/InheritanceMargin/InheritanceMarginViewModelTests.vb
+++ b/src/VisualStudio/Core/Test/InheritanceMargin/InheritanceMarginViewModelTests.vb
@@ -29,7 +29,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.InheritanceMargin
 
         Private Shared s_defaultMargin As Thickness = New Thickness(4, 1, 4, 1)
 
-        Private Shared s_indentMargin As Thickness = New Thickness(20, 1, 4, 1)
+        Private Shared s_indentMargin As Thickness = New Thickness(22, 1, 4, 1)
 
         Private Shared Async Function VerifyAsync(markup As String, languageName As String, expectedViewModels As Dictionary(Of Integer, InheritanceMarginViewModel)) As Task
             ' Add an lf before the document so that the line number starts
@@ -96,6 +96,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.InheritanceMargin
             For i = 0 To expected.MenuItemViewModels.Length - 1
                 Dim expectedMenuItem = expected.MenuItemViewModels(i)
                 Dim actualMenuItem = acutal.MenuItemViewModels(i)
+                VerifyMenuItem(expectedMenuItem, actualMenuItem)
             Next
 
         End Sub
@@ -108,17 +109,17 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.InheritanceMargin
             Dim expectedTargetMenuItem = TryCast(expected, TargetMenuItemViewModel)
             Dim acutalTargetMenuItem = TryCast(actual, TargetMenuItemViewModel)
             If expectedTargetMenuItem IsNot Nothing AndAlso acutalTargetMenuItem IsNot Nothing Then
-                Assert.Equal(expectedTargetMenuItem.Margin, acutalTargetMenuItem.Margin)
                 Return
             End If
 
             Dim expectedMemberMenuItem = TryCast(expected, MemberMenuItemViewModel)
             Dim acutalMemberMenuItem = TryCast(actual, MemberMenuItemViewModel)
-            If expectedTargetMenuItem IsNot Nothing AndAlso acutalTargetMenuItem IsNot Nothing Then
+            If expectedMemberMenuItem IsNot Nothing AndAlso acutalMemberMenuItem IsNot Nothing Then
                 Assert.Equal(expectedMemberMenuItem.Targets.Length, acutalMemberMenuItem.Targets.Length)
-                For i = 0 To expectedMemberMenuItem.Targets.Length
+                For i = 0 To expectedMemberMenuItem.Targets.Length - 1
                     VerifyMenuItem(expectedMemberMenuItem.Targets(i), acutalMemberMenuItem.Targets(i))
                 Next
+
                 Return
             End If
 
@@ -143,12 +144,12 @@ public class Bar : IBar
 {
 }"
             Dim tooltipTextForIBar = String.Format(ServicesVSResources._0_is_inherited, "interface IBar")
-            Dim targetForIBar = ImmutableArray.Create(
-                New TargetMenuItemViewModel("Bar", KnownMonikers.ClassPublic, "Bar", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForIBar = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Implementing_types, KnownMonikers.Implemented, ServicesVSResources.Implementing_types)).
+                Add(New TargetMenuItemViewModel("Bar", KnownMonikers.ClassPublic, "Bar", Nothing))
 
             Dim tooltipTextForBar = String.Format(ServicesVSResources._0_is_inherited, "class Bar")
-            Dim targetForBar = ImmutableArray.Create(
-                New TargetMenuItemViewModel("IBar", KnownMonikers.InterfacePublic, "IBar", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForBar = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Implemented_interfaces, KnownMonikers.Implementing, ServicesVSResources.Implemented_interfaces)).
+                Add(New TargetMenuItemViewModel("IBar", KnownMonikers.InterfacePublic, "IBar", Nothing))
 
             Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginViewModel) From {
                 {2, New InheritanceMarginViewModel(
@@ -179,24 +180,24 @@ public class Bar : AbsBar
 }"
 
             Dim tooltipTextForAbsBar = String.Format(ServicesVSResources._0_is_inherited, "class AbsBar")
-            Dim targetForAbsBar = ImmutableArray.Create(
-                New TargetMenuItemViewModel("Bar", KnownMonikers.Class, "Bar", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForAbsBar = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Derived_types, KnownMonikers.Overridden, ServicesVSResources.Derived_types)).
+                Add(New TargetMenuItemViewModel("Bar", KnownMonikers.ClassPublic, "Bar", Nothing))
 
             Dim tooltipTextForAbstractFoo = String.Format(ServicesVSResources._0_is_inherited, "abstract void AbsBar.Foo()")
-            Dim targetForAbsFoo = ImmutableArray.Create(
-                New TargetMenuItemViewModel("AbsBar.Foo()", KnownMonikers.MethodPublic, "AbsBar.Foo()", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForAbsFoo = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Overriding_members, KnownMonikers.Overridden, ServicesVSResources.Overriding_members)).
+                Add(New TargetMenuItemViewModel("Bar.Foo", KnownMonikers.MethodPublic, "Bar.Foo", Nothing))
 
             Dim tooltipTextForBar = String.Format(ServicesVSResources._0_is_inherited, "class Bar")
-            Dim targetForBar = ImmutableArray.Create(
-                New TargetMenuItemViewModel("AbsBar", KnownMonikers.Class, "AbsBar", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForBar = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Base_Types, KnownMonikers.Overriding, ServicesVSResources.Base_Types)).
+                Add(New TargetMenuItemViewModel("AbsBar", KnownMonikers.ClassPublic, "AbsBar", Nothing))
 
             Dim tooltipTextForOverrideFoo = String.Format(ServicesVSResources._0_is_inherited, "override void Bar.Foo()")
-            Dim targetForOverrideFoo = ImmutableArray.Create(
-                New TargetMenuItemViewModel("Bar.Foo()", KnownMonikers.MethodPublic, "Bar.Foo()", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForOverrideFoo = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Overridden_members, KnownMonikers.Overriding, ServicesVSResources.Overridden_members)).
+                Add(New TargetMenuItemViewModel("AbsBar.Foo", KnownMonikers.MethodPublic, "AbsBar.Foo", Nothing))
 
             Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginViewModel) From {
                 {2, New InheritanceMarginViewModel(
-                    KnownMonikers.Implemented,
+                    KnownMonikers.Overridden,
                     CreateTextBlock(tooltipTextForAbsBar),
                     tooltipTextForAbsBar,
                     1,
@@ -208,7 +209,7 @@ public class Bar : AbsBar
                     1,
                     targetForAbsFoo)},
                 {7, New InheritanceMarginViewModel(
-                    KnownMonikers.Implementing,
+                    KnownMonikers.Overriding,
                     CreateTextBlock(tooltipTextForBar),
                     tooltipTextForBar,
                     1,
@@ -229,21 +230,23 @@ public interface IBar2 : IBar1 { }
 public interface IBar3 : IBar2 { }
 "
             Dim tooltipTextForIBar1 = String.Format(ServicesVSResources._0_is_inherited, "interface IBar1")
-            Dim targetForIBar1 = ImmutableArray.Create(
-                New TargetMenuItemViewModel("IBar2", KnownMonikers.InterfacePublic, "IBar2", Nothing, s_defaultMargin),
-                New TargetMenuItemViewModel("IBar3", KnownMonikers.InterfacePublic, "IBar3", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForIBar1 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                New HeaderMenuItemViewModel(ServicesVSResources.Implementing_types, KnownMonikers.Implemented, ServicesVSResources.Implementing_types),
+                New TargetMenuItemViewModel("IBar2", KnownMonikers.InterfacePublic, "IBar2", Nothing),
+                New TargetMenuItemViewModel("IBar3", KnownMonikers.InterfacePublic, "IBar3", Nothing))
 
             Dim tooltipTextForIBar2 = String.Format(ServicesVSResources._0_is_inherited, "interface IBar2")
             Dim targetForIBar2 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
-                New HeaderMenuItemViewModel(ServicesVSResources.Implementing_members, KnownMonikers.Implementing, ServicesVSResources.Implementing_members),
-                New TargetMenuItemViewModel("IBar1", KnownMonikers.InterfacePublic, "IBar1", Nothing, s_indentMargin),
-                New HeaderMenuItemViewModel(ServicesVSResources.Implemented_members, KnownMonikers.Implemented, ServicesVSResources.Implemented_members),
-                New TargetMenuItemViewModel("IBar3", KnownMonikers.InterfacePublic, "IBar3", Nothing, s_indentMargin))
+                New HeaderMenuItemViewModel(ServicesVSResources.Inherited_interfaces, KnownMonikers.Implementing, ServicesVSResources.Inherited_interfaces),
+                New TargetMenuItemViewModel("IBar1", KnownMonikers.InterfacePublic, "IBar1", Nothing),
+                New HeaderMenuItemViewModel(ServicesVSResources.Implementing_types, KnownMonikers.Implemented, ServicesVSResources.Implementing_types),
+                New TargetMenuItemViewModel("IBar3", KnownMonikers.InterfacePublic, "IBar3", Nothing))
 
             Dim tooltipTextForIBar3 = String.Format(ServicesVSResources._0_is_inherited, "interface IBar3")
-            Dim targetForIBar3 = ImmutableArray.Create(
-                New TargetMenuItemViewModel("IBar1", KnownMonikers.InterfacePublic, "IBar1", Nothing, s_defaultMargin),
-                New TargetMenuItemViewModel("IBar2", KnownMonikers.InterfacePublic, "IBar2", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForIBar3 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                New HeaderMenuItemViewModel(ServicesVSResources.Inherited_interfaces, KnownMonikers.Implementing, ServicesVSResources.Inherited_interfaces),
+                New TargetMenuItemViewModel("IBar1", KnownMonikers.InterfacePublic, "IBar1", Nothing),
+                New TargetMenuItemViewModel("IBar2", KnownMonikers.InterfacePublic, "IBar2", Nothing)).CastArray(Of InheritanceMenuItemViewModel)
 
             Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginViewModel) From {
                 {2, New InheritanceMarginViewModel(
@@ -253,7 +256,7 @@ public interface IBar3 : IBar2 { }
                     1,
                     targetForIBar1)},
                 {3, New InheritanceMarginViewModel(
-                    KnownMonikers.Implemented,
+                    KnownMonikers.Implementing,
                     CreateTextBlock(tooltipTextForIBar2),
                     tooltipTextForIBar2,
                     1,
@@ -281,27 +284,32 @@ public class BarSample : IBar1
 }"
 
             Dim tooltipTextForIBar1 = String.Format(ServicesVSResources._0_is_inherited, "interface IBar1")
-            Dim targetForIBar1 = ImmutableArray.Create(
-                New TargetMenuItemViewModel("BarSample", KnownMonikers.ClassPublic, "BarSample", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForIBar1 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                New HeaderMenuItemViewModel(ServicesVSResources.Implementing_types, KnownMonikers.Implemented, ServicesVSResources.Implementing_types),
+                New TargetMenuItemViewModel("BarSample", KnownMonikers.ClassPublic, "BarSample", Nothing))
 
             Dim tooltipTextForE1AndE2InInterface = ServicesVSResources.Multiple_members_are_inherited
             Dim targetForE1AndE2InInterface = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
-                New MemberMenuItemViewModel("event EventHandler e1", KnownMonikers.EventPublic, "event EventHandler e1", ImmutableArray.Create(
-                    New TargetMenuItemViewModel("BarSample.e1", KnownMonikers.EventPublic, "BarSample.e1", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)),
-                New MemberMenuItemViewModel("event EventHandler e2", KnownMonikers.EventPublic, "event EventHandler e2", ImmutableArray.Create(
-                    New TargetMenuItemViewModel("BarSample.e2", KnownMonikers.EventPublic, "BarSample.e2", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel))) _
-            .CastArray(Of InheritanceMenuItemViewModel)
+                New MemberMenuItemViewModel("event EventHandler IBar1.e1", KnownMonikers.EventPublic, "event EventHandler IBar1.e1", ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                    New HeaderMenuItemViewModel(ServicesVSResources.Implementing_members, KnownMonikers.Implemented, ServicesVSResources.Implementing_members),
+                    New TargetMenuItemViewModel("BarSample.e1", KnownMonikers.EventPublic, "BarSample.e1", Nothing))),
+                New MemberMenuItemViewModel("event EventHandler IBar1.e2", KnownMonikers.EventPublic, "event EventHandler IBar1.e2", ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                    New HeaderMenuItemViewModel(ServicesVSResources.Implementing_members, KnownMonikers.Implemented, ServicesVSResources.Implementing_members),
+                    New TargetMenuItemViewModel("BarSample.e2", KnownMonikers.EventPublic, "BarSample.e2", Nothing))))
 
             Dim tooltipTextForBarSample = String.Format(ServicesVSResources._0_is_inherited, "class BarSample")
-            Dim targetForBarSample = ImmutableArray.Create(
-                New TargetMenuItemViewModel("IBar1", KnownMonikers.InterfacePublic, "IBar1", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)
+            Dim targetForBarSample = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                New HeaderMenuItemViewModel(ServicesVSResources.Implemented_interfaces, KnownMonikers.Implementing, ServicesVSResources.Implemented_interfaces),
+                New TargetMenuItemViewModel("IBar1", KnownMonikers.InterfaceInternal, "IBar1", Nothing))
 
             Dim tooltipTextForE1AndE2InBarSample = ServicesVSResources.Multiple_members_are_inherited
             Dim targetForE1AndE2InInBarSample = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
-                New MemberMenuItemViewModel("event EventHandler e1", KnownMonikers.EventPublic, "event EventHandler e1", ImmutableArray.Create(
-                    New TargetMenuItemViewModel("IBar1.BarSample.e1", KnownMonikers.EventPublic, "IBar1.BarSample.e1", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel)),
-                New MemberMenuItemViewModel("event EventHandler e2", KnownMonikers.EventPublic, "event EventHandler e2", ImmutableArray.Create(
-                    New TargetMenuItemViewModel("IBar1.BarSample.e2", KnownMonikers.EventPublic, "IBar1.BarSample.e2", Nothing, s_defaultMargin)).CastArray(Of InheritanceMenuItemViewModel))) _
+                New MemberMenuItemViewModel("virtual event EventHandler BarSample.e1", KnownMonikers.EventPublic, "virtual event EventHandler BarSample.e1", ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                    New HeaderMenuItemViewModel(ServicesVSResources.Implemented_members, KnownMonikers.Implementing, ServicesVSResources.Implemented_members),
+                    New TargetMenuItemViewModel("IBar1.e1", KnownMonikers.EventPublic, "IBar1.e1", Nothing)).CastArray(Of InheritanceMenuItemViewModel)),
+                New MemberMenuItemViewModel("virtual event EventHandler BarSample.e2", KnownMonikers.EventPublic, "virtual event EventHandler BarSample.e2", ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                    New HeaderMenuItemViewModel(ServicesVSResources.Implemented_members, KnownMonikers.Implementing, ServicesVSResources.Implemented_members),
+                    New TargetMenuItemViewModel("IBar1.e2", KnownMonikers.EventPublic, "IBar1.e2", Nothing)).CastArray(Of InheritanceMenuItemViewModel))) _
             .CastArray(Of InheritanceMenuItemViewModel)
 
             Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginViewModel) From {
diff --git a/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb b/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb
index 3495a0864e91f..2cf6212cbe614 100644
--- a/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb
+++ b/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb
@@ -133,6 +133,7 @@ csharp_style_implicit_object_creation_when_type_is_apparent = true
 csharp_style_inlined_variable_declaration = true
 csharp_style_pattern_local_over_anonymous_function = true
 csharp_style_prefer_index_operator = true
+csharp_style_prefer_null_check_over_type_check = true
 csharp_style_prefer_range_operator = true
 csharp_style_throw_expression = true
 csharp_style_unused_value_assignment_preference = discard_variable
@@ -362,6 +363,7 @@ csharp_style_implicit_object_creation_when_type_is_apparent = true
 csharp_style_inlined_variable_declaration = true
 csharp_style_pattern_local_over_anonymous_function = true
 csharp_style_prefer_index_operator = true
+csharp_style_prefer_null_check_over_type_check = true
 csharp_style_prefer_range_operator = true
 csharp_style_throw_expression = true
 csharp_style_unused_value_assignment_preference = discard_variable
diff --git a/src/VisualStudio/Core/Test/Progression/GraphProviderTests.vb b/src/VisualStudio/Core/Test/Progression/GraphProviderTests.vb
index e0ea73d5773e5..1a6bc6d74996d 100644
--- a/src/VisualStudio/Core/Test/Progression/GraphProviderTests.vb
+++ b/src/VisualStudio/Core/Test/Progression/GraphProviderTests.vb
@@ -16,7 +16,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
         <Fact, Trait(Traits.Feature, Traits.Features.Progression)>
         Public Sub TestGetContainsGraphQueries()
             Dim context = CreateGraphContext(GraphContextDirection.Contains, Array.Empty(Of GraphCategory)())
-            Dim queries = AbstractGraphProvider.GetGraphQueries(context)
+            Dim queries = AbstractGraphProvider.GetGraphQueries(context, threadingContext:=Nothing, asyncListener:=Nothing)
             Assert.Equal(queries.Single().GetType(), GetType(ContainsGraphQuery))
         End Sub
 
@@ -24,7 +24,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
         <Fact, Trait(Traits.Feature, Traits.Features.Progression)>
         Public Sub TestGetContainsGraphQueriesWithTarget()
             Dim context = CreateGraphContext(GraphContextDirection.Target, {CodeLinkCategories.Contains})
-            Dim queries = AbstractGraphProvider.GetGraphQueries(context)
+            Dim queries = AbstractGraphProvider.GetGraphQueries(context, threadingContext:=Nothing, asyncListener:=Nothing)
             Assert.Equal(queries.Single().GetType(), GetType(ContainsGraphQuery))
         End Sub
 
diff --git a/src/VisualStudio/Core/Test/Progression/MockGraphContext.vb b/src/VisualStudio/Core/Test/Progression/MockGraphContext.vb
index 59d22d1e0b23a..a534cee5a3462 100644
--- a/src/VisualStudio/Core/Test/Progression/MockGraphContext.vb
+++ b/src/VisualStudio/Core/Test/Progression/MockGraphContext.vb
@@ -12,6 +12,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
         Private ReadOnly _direction As GraphContextDirection
         Private ReadOnly _graph As Graph
         Private ReadOnly _inputNodes As ISet(Of GraphNode)
+        Private ReadOnly _outputNodes As New HashSet(Of GraphNode)
 
         Public Sub New(direction As GraphContextDirection, graph As Graph, inputNodes As IEnumerable(Of GraphNode))
             _direction = direction
@@ -89,7 +90,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
 
         Public ReadOnly Property OutputNodes As ISet(Of GraphNode) Implements IGraphContext.OutputNodes
             Get
-                Throw New NotImplementedException()
+                Return _outputNodes
             End Get
         End Property
 
diff --git a/src/VisualStudio/Core/Test/Progression/ProgressionTestState.vb b/src/VisualStudio/Core/Test/Progression/ProgressionTestState.vb
index 2b39583ca0074..687cfb38de5c2 100644
--- a/src/VisualStudio/Core/Test/Progression/ProgressionTestState.vb
+++ b/src/VisualStudio/Core/Test/Progression/ProgressionTestState.vb
@@ -3,7 +3,6 @@
 ' See the LICENSE file in the project root for more information.
 
 Imports System.Threading
-Imports System.Threading.Tasks
 Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.FindSymbols
@@ -14,10 +13,10 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
     Friend Class ProgressionTestState
         Implements IDisposable
 
-        Private ReadOnly _workspace As TestWorkspace
+        Public ReadOnly Workspace As TestWorkspace
 
         Public Sub New(workspace As TestWorkspace)
-            _workspace = workspace
+            Me.Workspace = workspace
         End Sub
 
         Public Shared Function Create(workspaceXml As XElement) As ProgressionTestState
@@ -27,30 +26,30 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
         End Function
 
         Public Function GetGraphWithDocumentNode(filePath As String) As Graph
-            Dim graphBuilder As New GraphBuilder(_workspace.CurrentSolution, CancellationToken.None)
-            Dim documentId = _workspace.Documents.Single(Function(d) d.FilePath = filePath).Id
-            graphBuilder.AddNodeForDocument(_workspace.CurrentSolution.GetDocument(documentId))
+            Dim graphBuilder As New GraphBuilder(Workspace.CurrentSolution)
+            Dim documentId = Workspace.Documents.Single(Function(d) d.FilePath = filePath).Id
+            graphBuilder.AddNodeForDocument(Workspace.CurrentSolution.GetDocument(documentId), CancellationToken.None)
             Return graphBuilder.Graph
         End Function
 
         Public Async Function GetGraphWithMarkedSymbolNodeAsync(Optional symbolTransform As Func(Of ISymbol, ISymbol) = Nothing) As Task(Of Graph)
-            Dim hostDocument As TestHostDocument = _workspace.Documents.Single(Function(d) d.CursorPosition.HasValue)
-            Dim document = _workspace.CurrentSolution.GetDocument(hostDocument.Id)
+            Dim hostDocument As TestHostDocument = Workspace.Documents.Single(Function(d) d.CursorPosition.HasValue)
+            Dim document = Workspace.CurrentSolution.GetDocument(hostDocument.Id)
             Dim symbol = Await GetMarkedSymbolAsync()
 
             If symbolTransform IsNot Nothing Then
                 symbol = symbolTransform(symbol)
             End If
 
-            Dim graphBuilder As New GraphBuilder(_workspace.CurrentSolution, CancellationToken.None)
-            graphBuilder.AddNodeAsync(symbol, document.Project, document).Wait(CancellationToken.None)
+            Dim graphBuilder As New GraphBuilder(Workspace.CurrentSolution)
+            Await graphBuilder.AddNodeAsync(symbol, document.Project, document, CancellationToken.None)
             Return graphBuilder.Graph
         End Function
 
         Public Async Function GetGraphContextAfterQuery(graph As Graph, graphQuery As IGraphQuery, direction As GraphContextDirection) As Task(Of IGraphContext)
             Dim graphContext As New MockGraphContext(direction, graph.Copy(), graph.Nodes)
-            Dim graphBuilder = Await graphQuery.GetGraphAsync(_workspace.CurrentSolution, graphContext, CancellationToken.None)
-            graphBuilder.ApplyToGraph(graphContext.Graph)
+            Dim graphBuilder = Await graphQuery.GetGraphAsync(Workspace.CurrentSolution, graphContext, CancellationToken.None)
+            graphBuilder.ApplyToGraph(graphContext.Graph, CancellationToken.None)
 
             Return graphContext
         End Function
@@ -58,13 +57,13 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
         Public Async Function GetGraphContextAfterQueryWithSolution(graph As Graph, solution As Solution, graphQuery As IGraphQuery, direction As GraphContextDirection) As Task(Of IGraphContext)
             Dim graphContext As New MockGraphContext(direction, graph.Copy(), graph.Nodes)
             Dim graphBuilder = Await graphQuery.GetGraphAsync(solution, graphContext, CancellationToken.None)
-            graphBuilder.ApplyToGraph(graphContext.Graph)
+            graphBuilder.ApplyToGraph(graphContext.Graph, CancellationToken.None)
 
             Return graphContext
         End Function
 
         Private Sub Dispose() Implements IDisposable.Dispose
-            _workspace.Dispose()
+            Workspace.Dispose()
         End Sub
 
         Public Async Function AssertMarkedSymbolLabelIsAsync(graphCommandId As String, label As String, description As String) As Task
@@ -76,13 +75,13 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
         End Function
 
         Public Function GetMarkedSymbolAsync() As Task(Of ISymbol)
-            Dim hostDocument As TestHostDocument = _workspace.Documents.Single(Function(d) d.CursorPosition.HasValue)
-            Dim document = _workspace.CurrentSolution.GetDocument(hostDocument.Id)
+            Dim hostDocument As TestHostDocument = Workspace.Documents.Single(Function(d) d.CursorPosition.HasValue)
+            Dim document = Workspace.CurrentSolution.GetDocument(hostDocument.Id)
             Return SymbolFinder.FindSymbolAtPositionAsync(document, hostDocument.CursorPosition.Value)
         End Function
 
         Public Function GetSolution() As Solution
-            Return _workspace.CurrentSolution
+            Return Workspace.CurrentSolution
         End Function
     End Class
 End Namespace
diff --git a/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests.vb b/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests.vb
index 1bd40c1b07f67..ff84d6ee40eb9 100644
--- a/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests.vb
+++ b/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests.vb
@@ -3,7 +3,9 @@
 ' See the LICENSE file in the project root for more information.
 
 Imports System.Threading.Tasks
+Imports Microsoft.CodeAnalysis.Editor.Shared.Utilities
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
+Imports Microsoft.CodeAnalysis.Shared.TestHooks
 Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.VisualStudio.GraphModel
 Imports Microsoft.VisualStudio.LanguageServices.Implementation.Progression
@@ -23,7 +25,9 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="C"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="C", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -55,7 +59,9 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="F"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="F", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -89,7 +95,9 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="M"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="M", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -136,7 +144,9 @@ End Namespace
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="C"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="C", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -184,7 +194,9 @@ End Namespace
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="Goo"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="Goo", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -231,7 +243,9 @@ End Namespace
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="Z"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="Z", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -270,7 +284,9 @@ End Namespace
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="D.B"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -304,7 +320,9 @@ End Namespace
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="C.B"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="C.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -326,7 +344,9 @@ End Namespace
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="D.B"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -360,7 +380,9 @@ End Namespace
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="A.D.B"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="A.D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -394,7 +416,9 @@ End Namespace
                         </Project>
                     </Workspace>)
 
-                Dim outputContext = Await testState.GetGraphContextAfterQuery(New Graph(), New SearchGraphQuery(searchPattern:="A.D.B"), GraphContextDirection.Custom)
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery(searchPattern:="A.D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 ' When searching, don't descend into projects with a null FilePath because they are artifacts and not
                 ' representable in the Solution Explorer, e.g., Venus projects create sub-projects with a null file
diff --git a/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests_NavigateTo.vb b/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests_NavigateTo.vb
new file mode 100644
index 0000000000000..c109b45bd8e82
--- /dev/null
+++ b/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests_NavigateTo.vb
@@ -0,0 +1,430 @@
+' Licensed to the .NET Foundation under one or more agreements.
+' The .NET Foundation licenses this file to you under the MIT license.
+' See the LICENSE file in the project root for more information.
+
+Imports System.Threading.Tasks
+Imports Microsoft.CodeAnalysis.Editor.Shared.Utilities
+Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
+Imports Microsoft.CodeAnalysis.Shared.TestHooks
+Imports Microsoft.CodeAnalysis.Test.Utilities
+Imports Microsoft.VisualStudio.GraphModel
+Imports Microsoft.VisualStudio.LanguageServices.Implementation.Progression
+Imports Roslyn.Test.Utilities
+
+Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
+    <UseExportProvider, Trait(Traits.Feature, Traits.Features.Progression)>
+    Public Class SearchGraphQueryTests_NavigateTo
+        <WpfFact>
+        Public Async Function SearchForType() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="C#" CommonReferences="true" FilePath="Z:\Project.csproj">
+                            <Document FilePath="Z:\Project.cs">
+                                class C { }
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("C", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes>
+                            <Node Id="(@1 @2 C)" Category="CodeSchema_Class" Icon="Microsoft.VisualStudio.Class.Internal" Label="C"/>
+                            <Node Id="(@1 @2)" Category="CodeSchema_ProjectItem" Label="Project.cs"/>
+                        </Nodes>
+                        <Links>
+                            <Link Source="(@1 @2)" Target="(@1 @2 C)" Category="Contains"/>
+                        </Links>
+                        <IdentifierAliases>
+                            <Alias n="1" Uri="Assembly=file:///Z:/Project.csproj"/>
+                            <Alias n="2" Uri="File=file:///Z:/Project.cs"/>
+                        </IdentifierAliases>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact, WorkItem(545474, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545474")>
+        Public Async Function SearchForNestedType() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="C#" CommonReferences="true" FilePath="Z:\Project.csproj">
+                            <Document FilePath="Z:\Project.cs">
+                                class C { class F { } }
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("F", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes>
+                            <Node Id="(@1 @2 F)" Category="CodeSchema_Class" Icon="Microsoft.VisualStudio.Class.Private" Label="F"/>
+                            <Node Id="(@1 @2)" Category="CodeSchema_ProjectItem" Label="Project.cs"/>
+                        </Nodes>
+                        <Links>
+                            <Link Source="(@1 @2)" Target="(@1 @2 F)" Category="Contains"/>
+                        </Links>
+                        <IdentifierAliases>
+                            <Alias n="1" Uri="Assembly=file:///Z:/Project.csproj"/>
+                            <Alias n="2" Uri="File=file:///Z:/Project.cs"/>
+                        </IdentifierAliases>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact>
+        Public Async Function SearchForMember() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="C#" CommonReferences="true" FilePath="Z:\Project.csproj">
+                            <Document FilePath="Z:\Project.cs">
+                                class C { void M(); }
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("M", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes>
+                            <Node Id="(@1 @2 M())" Category="CodeSchema_Method" Icon="Microsoft.VisualStudio.Method.Private" Label="M()"/>
+                            <Node Id="(@1 @2)" Category="CodeSchema_ProjectItem" Label="Project.cs"/>
+                        </Nodes>
+                        <Links>
+                            <Link Source="(@1 @2)" Target="(@1 @2 M())" Category="Contains"/>
+                        </Links>
+                        <IdentifierAliases>
+                            <Alias n="1" Uri="Assembly=file:///Z:/Project.csproj"/>
+                            <Alias n="2" Uri="File=file:///Z:/Project.cs"/>
+                        </IdentifierAliases>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact>
+        Public Async Function SearchForPartialType() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="Visual Basic" CommonReferences="true" FilePath="Z:\Project.vbproj">
+                            <Document FilePath="Z:\Project.vb">
+Namespace N
+    Partial Class C
+        Sub Goo()
+        End Sub
+    End Class
+End Namespace
+                            </Document>
+                            <Document FilePath="Z:\Project2.vb">
+Namespace N
+    Partial Class C
+        Sub Bar()
+        End Sub
+    End Class
+End Namespace
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("C", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes>
+                            <Node Id="(@1 @2 C)" Category="CodeSchema_Class" Icon="Microsoft.VisualStudio.Class.Internal" Label="C"/>
+                            <Node Id="(@1 @2)" Category="CodeSchema_ProjectItem" Label="Project2.vb"/>
+                            <Node Id="(@1 @3 C)" Category="CodeSchema_Class" Icon="Microsoft.VisualStudio.Class.Internal" Label="C"/>
+                            <Node Id="(@1 @3)" Category="CodeSchema_ProjectItem" Label="Project.vb"/>
+                        </Nodes>
+                        <Links>
+                            <Link Source="(@1 @2)" Target="(@1 @2 C)" Category="Contains"/>
+                            <Link Source="(@1 @3)" Target="(@1 @3 C)" Category="Contains"/>
+                        </Links>
+                        <IdentifierAliases>
+                            <Alias n="1" Uri="Assembly=file:///Z:/Project.vbproj"/>
+                            <Alias n="2" Uri="File=file:///Z:/Project2.vb"/>
+                            <Alias n="3" Uri="File=file:///Z:/Project.vb"/>
+                        </IdentifierAliases>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact>
+        Public Async Function SearchForMethodInPartialType() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="Visual Basic" CommonReferences="true" FilePath="Z:\Project.vbproj">
+                            <Document FilePath="Z:\Project.vb">
+Namespace N
+    Partial Class C
+        Sub Goo()
+        End Sub
+    End Class
+End Namespace
+                            </Document>
+                            <Document FilePath="Z:\Project2.vb">
+Namespace N
+    Partial Class C
+        Sub Bar()
+        End Sub
+    End Class
+End Namespace
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("Goo", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes>
+                            <Node Id="(@1 @2 Goo())" Category="CodeSchema_Method" Icon="Microsoft.VisualStudio.Method.Public" Label="Goo()"/>
+                            <Node Id="(@1 @2)" Category="CodeSchema_ProjectItem" Label="Project.vb"/>
+                        </Nodes>
+                        <Links>
+                            <Link Source="(@1 @2)" Target="(@1 @2 Goo())" Category="Contains"/>
+                        </Links>
+                        <IdentifierAliases>
+                            <Alias n="1" Uri="Assembly=file:///Z:/Project.vbproj"/>
+                            <Alias n="2" Uri="File=file:///Z:/Project.vb"/>
+                        </IdentifierAliases>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact>
+        Public Async Function SearchWithResultsAcrossMultipleTypeParts() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="Visual Basic" CommonReferences="true" FilePath="Z:\Project.vbproj">
+                            <Document FilePath="Z:\Project.vb">
+Namespace N
+    Partial Class C
+        Sub ZGoo()
+        End Sub
+    End Class
+End Namespace
+                            </Document>
+                            <Document FilePath="Z:\Project2.vb">
+Namespace N
+    Partial Class C
+        Sub ZBar()
+        End Sub
+    End Class
+End Namespace
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("Z", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes>
+                            <Node Id="(@1 @2 ZBar())" Category="CodeSchema_Method" Icon="Microsoft.VisualStudio.Method.Public" Label="ZBar()"/>
+                            <Node Id="(@1 @2)" Category="CodeSchema_ProjectItem" Label="Project2.vb"/>
+                            <Node Id="(@1 @3 ZGoo())" Category="CodeSchema_Method" Icon="Microsoft.VisualStudio.Method.Public" Label="ZGoo()"/>
+                            <Node Id="(@1 @3)" Category="CodeSchema_ProjectItem" Label="Project.vb"/>
+                        </Nodes>
+                        <Links>
+                            <Link Source="(@1 @2)" Target="(@1 @2 ZBar())" Category="Contains"/>
+                            <Link Source="(@1 @3)" Target="(@1 @3 ZGoo())" Category="Contains"/>
+                        </Links>
+                        <IdentifierAliases>
+                            <Alias n="1" Uri="Assembly=file:///Z:/Project.vbproj"/>
+                            <Alias n="2" Uri="File=file:///Z:/Project2.vb"/>
+                            <Alias n="3" Uri="File=file:///Z:/Project.vb"/>
+                        </IdentifierAliases>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact>
+        Public Async Function SearchForDottedName1() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="C#" CommonReferences="true" FilePath="Z:\Project.csproj">
+                            <Document FilePath="Z:\Project.cs">
+                                class Dog { void Bark() { } }
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes>
+                            <Node Id="(@1 @2 Bark())" Category="CodeSchema_Method" Icon="Microsoft.VisualStudio.Method.Private" Label="Bark()"/>
+                            <Node Id="(@1 @2)" Category="CodeSchema_ProjectItem" Label="Project.cs"/>
+                        </Nodes>
+                        <Links>
+                            <Link Source="(@1 @2)" Target="(@1 @2 Bark())" Category="Contains"/>
+                        </Links>
+                        <IdentifierAliases>
+                            <Alias n="1" Uri="Assembly=file:///Z:/Project.csproj"/>
+                            <Alias n="2" Uri="File=file:///Z:/Project.cs"/>
+                        </IdentifierAliases>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact>
+        Public Async Function SearchForDottedName2() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="C#" CommonReferences="true" FilePath="Z:\Project.csproj">
+                            <Document FilePath="Z:\Project.cs">
+                                class Dog { void Bark() { } }
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("C.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes/>
+                        <Links/>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact>
+        Public Async Function SearchForDottedName3() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="C#" CommonReferences="true" FilePath="Z:\Project.csproj">
+                            <Document FilePath="Z:\Project.cs">
+                                namespace Animal { class Dog&lt;X&gt; { void Bark() { } } }
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes>
+                            <Node Id="(@1 @2 Bark())" Category="CodeSchema_Method" Icon="Microsoft.VisualStudio.Method.Private" Label="Bark()"/>
+                            <Node Id="(@1 @2)" Category="CodeSchema_ProjectItem" Label="Project.cs"/>
+                        </Nodes>
+                        <Links>
+                            <Link Source="(@1 @2)" Target="(@1 @2 Bark())" Category="Contains"/>
+                        </Links>
+                        <IdentifierAliases>
+                            <Alias n="1" Uri="Assembly=file:///Z:/Project.csproj"/>
+                            <Alias n="2" Uri="File=file:///Z:/Project.cs"/>
+                        </IdentifierAliases>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact>
+        Public Async Function SearchForDottedName4() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="C#" CommonReferences="true" FilePath="Z:\Project.csproj">
+                            <Document FilePath="Z:\Project.cs">
+                                namespace Animal { class Dog&lt;X&gt; { void Bark() { } } }
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("A.D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes>
+                            <Node Id="(@1 @2 Bark())" Category="CodeSchema_Method" Icon="Microsoft.VisualStudio.Method.Private" Label="Bark()"/>
+                            <Node Id="(@1 @2)" Category="CodeSchema_ProjectItem" Label="Project.cs"/>
+                        </Nodes>
+                        <Links>
+                            <Link Source="(@1 @2)" Target="(@1 @2 Bark())" Category="Contains"/>
+                        </Links>
+                        <IdentifierAliases>
+                            <Alias n="1" Uri="Assembly=file:///Z:/Project.csproj"/>
+                            <Alias n="2" Uri="File=file:///Z:/Project.cs"/>
+                        </IdentifierAliases>
+                    </DirectedGraph>)
+            End Using
+        End Function
+
+        <WpfFact>
+        Public Async Function SearchWithNullFilePathsOnProject() As Task
+            Using testState = ProgressionTestState.Create(
+                    <Workspace>
+                        <Project Language="C#" CommonReferences="true" FilePath=<%= TestWorkspace.NullFilePath %>>
+                            <Document FilePath="Z:\SomeVenusDocument.aspx.cs">
+                                namespace Animal { class Dog&lt;X&gt; { void Bark() { } } }
+                            </Document>
+                        </Project>
+                    </Workspace>)
+
+                testState.Workspace.SetOptions(testState.Workspace.Options.WithChangedOption(ProgressionOptions.SearchUsingNavigateToEngine, True))
+                Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
+                Dim outputContext = Await testState.GetGraphContextAfterQuery(
+                    New Graph(), New SearchGraphQuery("A.D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+
+                ' When searching, don't descend into projects with a null FilePath because they are artifacts and not
+                ' representable in the Solution Explorer, e.g., Venus projects create sub-projects with a null file
+                ' path for each .aspx file.  Documents, on the other hand, are never allowed to have a null file path
+                ' and as such are not tested here.  The project/document structure for these scenarios would look
+                ' similar to this:
+                '
+                '    Project: SomeVenusProject, FilePath=C:\path\to\project.csproj
+                '      + Document: SomeVenusDocument.aspx, FilePath=C:\path\to\SomeVenusDocument.aspx
+                '        + Project: 1_SomeNamespace_SomeVenusDocument.aspx, FilePath=null        <- the problem is here
+                '          + Document: SomeVenusDocument.aspx.cs
+                AssertSimplifiedGraphIs(
+                    outputContext.Graph,
+                    <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
+                        <Nodes/>
+                        <Links/>
+                    </DirectedGraph>)
+            End Using
+        End Function
+    End Class
+End Namespace
diff --git a/src/VisualStudio/Core/Test/PullMemberUp/PullMemberUpViewModelTest.vb b/src/VisualStudio/Core/Test/PullMemberUp/PullMemberUpViewModelTest.vb
index 85d1ba5e6d7c0..88c32b9cc177a 100644
--- a/src/VisualStudio/Core/Test/PullMemberUp/PullMemberUpViewModelTest.vb
+++ b/src/VisualStudio/Core/Test/PullMemberUp/PullMemberUpViewModelTest.vb
@@ -230,6 +230,7 @@ class MyClass : Level1BaseClass, Level1Interface
             If (member Is Nothing) Then
                 Assert.True(False, $"No member called {name} found")
             End If
+
             Return member
         End Function
 
diff --git a/src/VisualStudio/Core/Test/SolutionExplorer/SourceGeneratorItemTests.vb b/src/VisualStudio/Core/Test/SolutionExplorer/SourceGeneratorItemTests.vb
index 81b813e0e5abe..b7a0aac19bbd2 100644
--- a/src/VisualStudio/Core/Test/SolutionExplorer/SourceGeneratorItemTests.vb
+++ b/src/VisualStudio/Core/Test/SolutionExplorer/SourceGeneratorItemTests.vb
@@ -19,7 +19,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.SolutionExplorer
         Public Sub SourceGeneratorsListed()
             Dim workspaceXml =
                 <Workspace>
-                    <Project Language="C#" CommonReferences="true">
+                    <Project Language="C#" CommonReferences="true" LanguageVersion="Preview">
                     </Project>
                 </Workspace>
 
@@ -39,7 +39,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.SolutionExplorer
         Public Async Function PlaceholderItemCreateIfGeneratorProducesNoFiles() As Task
             Dim workspaceXml =
                 <Workspace>
-                    <Project Language="C#" CommonReferences="true">
+                    <Project Language="C#" CommonReferences="true" LanguageVersion="Preview">
                     </Project>
                 </Workspace>
 
@@ -63,7 +63,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.SolutionExplorer
         Public Async Function SingleSourceGeneratedFileProducesItem() As Task
             Dim workspaceXml =
                 <Workspace>
-                    <Project Language="C#" CommonReferences="true">
+                    <Project Language="C#" CommonReferences="true" LanguageVersion="Preview">
                         <AdditionalDocument FilePath="Test.txt"></AdditionalDocument>
                     </Project>
                 </Workspace>
@@ -92,7 +92,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.SolutionExplorer
         Public Async Function MultipleSourceGeneratedFilesProducesSortedItem() As Task
             Dim workspaceXml =
                 <Workspace>
-                    <Project Language="C#" CommonReferences="true">
+                    <Project Language="C#" CommonReferences="true" LanguageVersion="Preview">
                         <AdditionalDocument FilePath="Test1.txt"></AdditionalDocument>
                         <AdditionalDocument FilePath="Test2.txt"></AdditionalDocument>
                         <AdditionalDocument FilePath="Test3.txt"></AdditionalDocument>
@@ -124,7 +124,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.SolutionExplorer
         Public Async Function ChangeToNoGeneratedDocumentsUpdatesListCorrectly() As Task
             Dim workspaceXml =
                 <Workspace>
-                    <Project Language="C#" CommonReferences="true">
+                    <Project Language="C#" CommonReferences="true" LanguageVersion="Preview">
                         <AdditionalDocument FilePath="Test1.txt"></AdditionalDocument>
                     </Project>
                 </Workspace>
@@ -153,7 +153,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.SolutionExplorer
         Public Async Function AddingAGeneratedDocumentUpdatesListCorrectly() As Task
             Dim workspaceXml =
                 <Workspace>
-                    <Project Language="C#" CommonReferences="true">
+                    <Project Language="C#" CommonReferences="true" LanguageVersion="Preview">
                     </Project>
                 </Workspace>
 
diff --git a/src/VisualStudio/Core/Test/SymbolSearch/SymbolSearchUpdateEngineTests.vb b/src/VisualStudio/Core/Test/SymbolSearch/SymbolSearchUpdateEngineTests.vb
index 7817dda6ff145..8df2aa72bc255 100644
--- a/src/VisualStudio/Core/Test/SymbolSearch/SymbolSearchUpdateEngineTests.vb
+++ b/src/VisualStudio/Core/Test/SymbolSearch/SymbolSearchUpdateEngineTests.vb
@@ -619,6 +619,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.SymbolSearch
             Else
                 SetupDownloadPatch(clientMock, remoteControlMock)
             End If
+
             Return remoteControlMock
         End Function
 
diff --git a/src/VisualStudio/Core/Test/UnusedReferences/TestProjectAssetsFile.vb b/src/VisualStudio/Core/Test/UnusedReferences/TestProjectAssetsFile.vb
index 3ec77f7b60a46..6659a8a2cc26f 100644
--- a/src/VisualStudio/Core/Test/UnusedReferences/TestProjectAssetsFile.vb
+++ b/src/VisualStudio/Core/Test/UnusedReferences/TestProjectAssetsFile.vb
@@ -19,11 +19,13 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.UnusedReferences
 
             Dim libraries = BuildLibraries(allReferences)
             Dim targets = BuildTargets(targetFramework, allReferences)
+            Dim project = BuildProject(targetFramework)
 
             Dim projectAssets As ProjectAssetsFile = New ProjectAssetsFile With {
                 .Version = version,
                 .Targets = targets,
-                .Libraries = libraries
+                .Libraries = libraries,
+                .Project = project
             }
 
             Return projectAssets
@@ -88,5 +90,15 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.UnusedReferences
                     Return String.Empty
                 End Function)
         End Function
+
+        Private Function BuildProject(targetFramework As String) As ProjectAssetsProject
+            ' Frameworks won't always specify a set of dependencies.
+            ' This ensures the project asset reader does not error in these cases.
+            Return New ProjectAssetsProject With {
+                 .Frameworks = New Dictionary(Of String, ProjectAssetsProjectFramework) From {
+                    {targetFramework, New ProjectAssetsProjectFramework}
+                 }
+            }
+        End Function
     End Module
 End Namespace
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs
index 219bebc36f675..bb73bb99f91b5 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs
@@ -373,5 +373,38 @@ public void M(string s, int i, int i2)
             VisualStudio.Editor.SendKeys(VirtualKey.Down);
             VisualStudio.Editor.Verify.CurrentLineText("M(" + parameterText + ", 0, 0)");
         }
+
+        [WpfFact]
+        [WorkItem(54038, "https://github.com/dotnet/roslyn/issues/54038")]
+        public void InsertPreprocessorSnippet()
+        {
+            SetUpEditor(@"
+using System;
+public class TestClass
+{
+$$
+}
+");
+
+            VisualStudio.Editor.SendKeys("#i");
+
+            VisualStudio.Editor.SendKeys(VirtualKey.Tab);
+            VisualStudio.Editor.Verify.CurrentLineText("#if$$", assertCaretPosition: true);
+
+            VisualStudio.Editor.SendKeys(VirtualKey.Tab);
+            VisualStudio.Editor.Verify.CurrentLineText("#if true$$", assertCaretPosition: true);
+
+            var expected = @"
+using System;
+public class TestClass
+{
+#if true
+
+#endif
+}
+";
+
+            AssertEx.EqualOrDiff(expected, VisualStudio.Editor.GetText());
+        }
     }
 }
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/FindReferencesWindow_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/FindReferencesWindow_InProc.cs
index 21a550b58ec2f..4e648b6deea9d 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/FindReferencesWindow_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/FindReferencesWindow_InProc.cs
@@ -37,6 +37,7 @@ public Reference[] GetContents(string windowCaption)
                         groupingPriority: 0);
                     newColumnsStates.Add(newState);
                 }
+
                 tableControl.SetColumnStates(newColumnsStates);
 
                 // Force a refresh, if necessary. This doesn't re-run the Find References or
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/SolutionExplorer_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/SolutionExplorer_InProc.cs
index 4a4c5637182da..7d198c3c9398c 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/SolutionExplorer_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/SolutionExplorer_InProc.cs
@@ -192,6 +192,7 @@ public void EditProjectFile(string projectName)
             {
                 throw new ArgumentException($"Could not find project file, current hierarchy items '{string.Join(", ", rootHierarchyItems.Select(x => x.Name))}'");
             }
+
             project.Select(EnvDTE.vsUISelectionType.vsUISelectionTypeSelect);
             ExecuteCommand("Project.EditProjectFile");
         }
@@ -210,6 +211,7 @@ public void CreateSolution(string solutionName, string solutionElementString)
             {
                 throw new ArgumentException(nameof(solutionElementString));
             }
+
             CreateSolution(solutionName);
 
             foreach (var projectElement in solutionElement.Elements("Project"))
@@ -313,6 +315,7 @@ public void RemoveProjectReference(string projectName, string projectReferenceNa
                 var projectReference = references.Where(x => x.ContainingProject != null).Select(x => x.Name);
                 throw new ArgumentException($"reference to project {projectReferenceName} not found, references: '{string.Join(", ", projectReference)}'");
             }
+
             reference.Remove();
         }
 
@@ -324,6 +327,7 @@ public void OpenSolution(string path, bool saveExistingSolutionIfExists = false)
             {
                 CloseSolution(saveExistingSolutionIfExists);
             }
+
             dte.Solution.Open(path);
 
             _solution = (EnvDTE80.Solution2)dte.Solution;
@@ -806,6 +810,7 @@ int IVsUpdateSolutionEvents.UpdateSolution_Begin(ref int pfCancelUpdate)
                 {
                     pfCancelUpdate = 1;
                 }
+
                 return 0;
             }
 
@@ -839,6 +844,7 @@ int IVsUpdateSolutionEvents2.UpdateSolution_Begin(ref int pfCancelUpdate)
                 {
                     pfCancelUpdate = 1;
                 }
+
                 return 0;
             }
 
@@ -884,6 +890,7 @@ private int UpdateSolution_StartUpdate(ref int pfCancelUpdate)
                 {
                     pfCancelUpdate = 1;
                 }
+
                 return 0;
             }
 
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
index b4106b5aaede0..dc52c2ba9508c 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
@@ -300,6 +300,7 @@ bool filterTag(IMappingTagSpan<ITag> tag)
             {
                 return tag.Tag.GetType().Equals(type);
             }
+
             var service = GetComponentModelService<IViewTagAggregatorFactoryService>();
             var aggregator = service.CreateTagAggregator<ITag>(view);
             var allTags = aggregator.GetTags(new SnapshotSpan(view.TextSnapshot, 0, view.TextSnapshot.Length));
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioInstanceFactory.cs b/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioInstanceFactory.cs
index 2428414f901d7..2ed1280bb6298 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioInstanceFactory.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioInstanceFactory.cs
@@ -276,6 +276,7 @@ private static ISetupInstance LocateVisualStudioInstance(ImmutableHashSet<string
                         isMatch &= instance.GetInstallationVersion().StartsWith(VsProductVersion);
                     }
                 }
+
                 return isMatch;
             });
 
diff --git a/src/VisualStudio/LiveShare/Impl/Client/LanguageServiceUtils.cs b/src/VisualStudio/LiveShare/Impl/Client/LanguageServiceUtils.cs
index 11e884a3cbb69..e922257ddd994 100644
--- a/src/VisualStudio/LiveShare/Impl/Client/LanguageServiceUtils.cs
+++ b/src/VisualStudio/LiveShare/Impl/Client/LanguageServiceUtils.cs
@@ -35,6 +35,7 @@ public static bool TryParseJson<T>(object json, out T t)
             {
                 return true;
             }
+
             try
             {
                 t = ((JObject)json).ToObject<T>();
diff --git a/src/VisualStudio/LiveShare/Impl/Client/RemoteDiagnosticListTable.cs b/src/VisualStudio/LiveShare/Impl/Client/RemoteDiagnosticListTable.cs
index 5d407bad2c7c9..5cbbfc57af4b5 100644
--- a/src/VisualStudio/LiveShare/Impl/Client/RemoteDiagnosticListTable.cs
+++ b/src/VisualStudio/LiveShare/Impl/Client/RemoteDiagnosticListTable.cs
@@ -30,8 +30,8 @@ internal class RemoteDiagnosticListTable : VisualStudioBaseDiagnosticListTable
         [ImportingConstructor]
         [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Incorrectly used in production code: https://github.com/dotnet/roslyn/issues/42839")]
         public RemoteDiagnosticListTable(
-            SVsServiceProvider serviceProvider, RemoteLanguageServiceWorkspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider) :
-            base(workspace, provider)
+            SVsServiceProvider serviceProvider, RemoteLanguageServiceWorkspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider)
+            : base(workspace, provider)
         {
             _source = new LiveTableDataSource(workspace, diagnosticService, IdentifierString);
             AddInitialTableSource(workspace.CurrentSolution, _source);
@@ -54,6 +54,7 @@ protected override void AddTableSourceIfNecessary(Solution solution)
             {
                 return;
             }
+
             AddTableSource(_source);
         }
 
diff --git a/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspace.cs b/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspace.cs
index 829283c6afaeb..ca25e602e59a4 100644
--- a/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspace.cs
+++ b/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspace.cs
@@ -386,6 +386,7 @@ public override void OpenDocument(DocumentId documentId, bool activate = true)
                 {
                     return;
                 }
+
                 _threadingContext.JoinableTaskFactory.Run(async () =>
                 {
                     await _session.DownloadFileAsync(_session.ConvertLocalPathToSharedUri(doc.FilePath), CancellationToken.None).ConfigureAwait(true);
diff --git a/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspaceHost.cs b/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspaceHost.cs
index b9b56e88512cd..5a172d35bea0d 100644
--- a/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspaceHost.cs
+++ b/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspaceHost.cs
@@ -159,6 +159,7 @@ private void CloseAllProjects()
             {
                 _remoteLanguageServiceWorkspace.OnProjectRemoved(projectId);
             }
+
             _loadedProjects = _loadedProjects.Clear();
             _loadedProjectInfo = _loadedProjectInfo.Clear();
         }
diff --git a/src/VisualStudio/TestUtilities2/CodeModel/Mocks/MockTextPoint.vb b/src/VisualStudio/TestUtilities2/CodeModel/Mocks/MockTextPoint.vb
index 19a3eee5cccf0..1826f5cdd35f4 100644
--- a/src/VisualStudio/TestUtilities2/CodeModel/Mocks/MockTextPoint.vb
+++ b/src/VisualStudio/TestUtilities2/CodeModel/Mocks/MockTextPoint.vb
@@ -111,6 +111,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.CodeModel.Mocks
                 If _point.IsInVirtualSpace Then
                     result += _point.VirtualSpaces
                 End If
+
                 Return result
             End Get
         End Property
diff --git a/src/VisualStudio/VisualBasic/Impl/CodeModel/VisualBasicCodeModelService.NodeNameGenerator.vb b/src/VisualStudio/VisualBasic/Impl/CodeModel/VisualBasicCodeModelService.NodeNameGenerator.vb
index 15a8fc8050c64..0cac9701d4650 100644
--- a/src/VisualStudio/VisualBasic/Impl/CodeModel/VisualBasicCodeModelService.NodeNameGenerator.vb
+++ b/src/VisualStudio/VisualBasic/Impl/CodeModel/VisualBasicCodeModelService.NodeNameGenerator.vb
@@ -173,6 +173,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.CodeModel
                         If methodStatement.TypeParameterList IsNot Nothing Then
                             AppendArity(builder, methodStatement.TypeParameterList.Parameters.Count)
                         End If
+
                         AppendParameterList(builder, methodStatement.ParameterList)
 
                     Case SyntaxKind.FunctionStatement,
@@ -183,6 +184,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.CodeModel
                         If methodStatement.TypeParameterList IsNot Nothing Then
                             AppendArity(builder, methodStatement.TypeParameterList.Parameters.Count)
                         End If
+
                         AppendParameterList(builder, methodStatement.ParameterList)
 
                     Case SyntaxKind.DeclareFunctionStatement,
@@ -204,6 +206,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.CodeModel
                             builder.Append("_"c)
                             AppendTypeName(builder, DirectCast(operatorStatement.AsClause, SimpleAsClauseSyntax).Type)
                         End If
+
                         AppendParameterList(builder, operatorStatement.ParameterList)
 
                     Case SyntaxKind.ConstructorBlock
diff --git a/src/VisualStudio/VisualBasic/Impl/Help/VisualBasicHelpContextService.Visitor.vb b/src/VisualStudio/VisualBasic/Impl/Help/VisualBasicHelpContextService.Visitor.vb
index 3c7b4c3e60236..0e132cd6942f4 100644
--- a/src/VisualStudio/VisualBasic/Impl/Help/VisualBasicHelpContextService.Visitor.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Help/VisualBasicHelpContextService.Visitor.vb
@@ -110,6 +110,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Help
                 If Not node.IntoKeyword.IsMissing Then
                     result = HelpKeywords.QueryAggregateInto
                 End If
+
                 result = HelpKeywords.QueryAggregate
             End Sub
 
diff --git a/src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicCodeCleanupFixerProvider.vb b/src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicCodeCleanupFixerProvider.vb
index d1df51e52f392..850c805e40da7 100644
--- a/src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicCodeCleanupFixerProvider.vb
+++ b/src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicCodeCleanupFixerProvider.vb
@@ -1,4 +1,4 @@
-' Licensed to the .NET Foundation under one or more agreements.
+' Licensed to the .NET Foundation under one or more agreements.
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
@@ -23,4 +23,4 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.CodeCleanup
             MyBase.New(codeCleanUpFixers)
         End Sub
     End Class
-End Namespace
\ No newline at end of file
+End Namespace
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
index bf0bfc8251a35..4d6d131fb3d37 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
@@ -34,6 +34,8 @@
                               Content="{x:Static local:AdvancedOptionPageStrings.Option_Show_Remove_Unused_References_command_in_Solution_Explorer_experimental}" />
                     <CheckBox x:Name="Enable_file_logging_for_diagnostics"
                               Content="{x:Static local:AdvancedOptionPageStrings.Option_Enable_file_logging_for_diagnostics}" />
+                    <CheckBox x:Name="Skip_analyzers_for_implicitly_triggered_builds"
+                              Content="{x:Static local:AdvancedOptionPageStrings.Option_Skip_analyzers_for_implicitly_triggered_builds}" />
                 </StackPanel>
             </GroupBox>
             <GroupBox x:Uid="ImportDirectivesGroupBox"
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
index 67cd97f66541a..ba84bbeddd0db 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
@@ -47,6 +47,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
             BindToOption(Background_analysis_scope_full_solution, SolutionCrawlerOptions.BackgroundAnalysisScopeOption, BackgroundAnalysisScope.FullSolution, LanguageNames.VisualBasic)
             BindToOption(Use_64bit_analysis_process, RemoteHostOptions.OOP64Bit)
             BindToOption(Enable_file_logging_for_diagnostics, InternalDiagnosticsOptions.EnableFileLoggingForDiagnostics)
+            BindToOption(Skip_analyzers_for_implicitly_triggered_builds, FeatureOnOffOptions.SkipAnalyzersForImplicitlyTriggeredBuilds)
             BindToOption(Show_Remove_Unused_References_command_in_Solution_Explorer_experimental, FeatureOnOffOptions.OfferRemoveUnusedReferences,
                          Function()
                              ' If the option has Not been set by the user, check if the option to remove unused references
@@ -145,7 +146,12 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
             BindToOption(SuppressHintsWhenParameterNameMatchesTheMethodsIntent, InlineHintsOptions.SuppressForParametersThatMatchMethodIntent, LanguageNames.VisualBasic)
             BindToOption(SuppressHintsWhenParameterNamesDifferOnlyBySuffix, InlineHintsOptions.SuppressForParametersThatDifferOnlyBySuffix, LanguageNames.VisualBasic)
 
-            BindToOption(ShowInheritanceMargin, FeatureOnOffOptions.ShowInheritanceMargin, LanguageNames.VisualBasic)
+            BindToOption(ShowInheritanceMargin, FeatureOnOffOptions.ShowInheritanceMargin, LanguageNames.VisualBasic,
+                         Function()
+                             ' If the option has not been set by the user, check if the option Is enabled from experimentation.
+                             ' If so, default to that. Otherwise default to disabled
+                             Return If(experimentationService?.IsExperimentEnabled(WellKnownExperimentNames.InheritanceMargin), False)
+                         End Function)
         End Sub
 
         ' Since this dialog is constructed once for the lifetime of the application and VS Theme can be changed after the application has started,
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
index e3e5208d35774..2828919a0b441 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
@@ -293,6 +293,9 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
         Public ReadOnly Property Option_Enable_file_logging_for_diagnostics As String =
             ServicesVSResources.Enable_file_logging_for_diagnostics
 
+        Public ReadOnly Property Option_Skip_analyzers_for_implicitly_triggered_builds As String =
+            ServicesVSResources.Skip_analyzers_for_implicitly_triggered_builds
+
         Public ReadOnly Property Show_inheritance_margin As String =
             ServicesVSResources.Show_inheritance_margin
 
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.OnOff.vb b/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.OnOff.vb
index a791eca4dca2c..ff9d104fd458a 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.OnOff.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.OnOff.vb
@@ -113,5 +113,14 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
                 SetBooleanOption(FeatureOnOffOptions.OfferRemoveUnusedReferences, value)
             End Set
         End Property
+
+        Public Property SkipAnalyzersForImplicitlyTriggeredBuilds As Integer
+            Get
+                Return If(GetBooleanOption(FeatureOnOffOptions.SkipAnalyzersForImplicitlyTriggeredBuilds), 1, 0)
+            End Get
+            Set(value As Integer)
+                SetBooleanOption(FeatureOnOffOptions.SkipAnalyzersForImplicitlyTriggeredBuilds, value <> 0)
+            End Set
+        End Property
     End Class
 End Namespace
diff --git a/src/VisualStudio/VisualBasic/Impl/Snippets/SnippetExpansionClient.vb b/src/VisualStudio/VisualBasic/Impl/Snippets/SnippetExpansionClient.vb
index 234ddd3b70249..db67e096800da 100644
--- a/src/VisualStudio/VisualBasic/Impl/Snippets/SnippetExpansionClient.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Snippets/SnippetExpansionClient.vb
@@ -229,6 +229,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Snippets
                                                                ordinalIgnoreCaseStringComparer.Equals(x.XmlNamespace.Value.ToString(), xmlNamespaceImportsClause.XmlNamespace.Value.ToString())) Then
                         uniqueClauses.Add(clause)
                     End If
+
                     Continue For
                 End If
             Next
diff --git a/src/VisualStudio/VisualBasic/Impl/VSPackage.resx b/src/VisualStudio/VisualBasic/Impl/VSPackage.resx
index a69f19d3134c8..e75e5a640b154 100644
--- a/src/VisualStudio/VisualBasic/Impl/VSPackage.resx
+++ b/src/VisualStudio/VisualBasic/Impl/VSPackage.resx
@@ -128,7 +128,7 @@
     <value>Visual Basic Editor</value>
   </data>
   <data name="10160" xml:space="preserve">
-    <value>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</value>
+    <value>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</value>
     <comment>Advanced options page keywords</comment>
   </data>
   <data name="102" xml:space="preserve">
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.cs.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.cs.xlf
index f1301cc8ea921..c43220b35bb48 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.cs.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.cs.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">Zobrazovat vložené nápovědy;Automatické vložení koncových konstruktorů;Změnit nastavení přehledného výpisu;Změnit režim sbalení;Automatické vkládání členů Interface a MustOverride;Zobrazit nebo skrýt oddělovače řádků procedur;Zapnout nebo vypnout návrhy oprav;Zapnout nebo vypnout zvýrazňování odkazů a klíčových slov;Regex;Obarvit regulární výrazy;Zvýrazňovat související komponenty pod kurzorem;Nahlásit neplatné regulární výrazy;reg. výr.;regulární výraz;Používat rozšířené barvy;Barevné schéma editoru;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.de.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.de.xlf
index f545b1377989f..72eb3a80f58fd 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.de.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.de.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">Inline-Hinweise anzeigen;Endkonstrukte automatisch einfügen;Einstellungen für automatische Strukturierung und Einrückung ändern;Gliederungsmodus ändern;Schnittstellen- und MustOverride-Member automatisch einfügen;Zeilentrennzeichen zwischen Prozeduren anzeigen oder ausblenden;Vorschläge für Fehlerkorrektur ein- oder ausschalten;Hervorhebung von Verweisen und Schlüsselwörtern ein- oder ausschalten;Regex;Reguläre Ausdrücke farbig markieren;Verwandte Komponenten unter Cursor hervorheben;Ungültige reguläre Ausdrücke melden;regex;regulärer Ausdruck;nErweiterte Farben verwenden;Editor-Farbschema;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.es.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.es.xlf
index 65ad78eb34fa0..4774410bcdb3d 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.es.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.es.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">Mostrar sugerencias insertadas;Inserción automática de construcciones End;Cambiar configuración de la lista descriptiva;Cambiar modo de esquematización;Inserción automática de miembros Interface y MustOverride;Mostrar u ocultar separadores de línea de procedimientos;Activar o desactivar sugerencias de corrección de errores;Activar o desactivar resaltado de referencias y palabras clave;Regex;Colorear expresiones regulares;Resaltar componentes relacionados bajo el cursor;Informar sobre expresiones regulares no válidas;regex;expresión regular;Usar colores mejorados;Combinación de colores del editor;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.fr.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.fr.xlf
index 55d1ccfdb9da3..3743b36090c47 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.fr.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.fr.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">Afficher les indicateurs inline;Insertion automatique des constructions de fin;Changer les paramètres de listing en mode Pretty;Changer le mode Plan;Insertion automatique des membres Interface et MustOverride;Afficher ou masquer les séparateurs de ligne de procédure;Activer ou désactiver les suggestions de correction d'erreurs;Activer ou désactiver la mise en surbrillance des références et des mots clés;Regex;Mettre en couleurs les expressions régulières;Mettre en surbrillance les composants connexes sous le curseur;Signaler les expressions régulières non valides;regex;expression régulière;Utiliser des couleurs améliorées;Modèle de couleurs de l'éditeur;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.it.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.it.xlf
index a5f8592425d0d..0bb83c019b3e9 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.it.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.it.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">Visualizza suggerimenti inline;Inserimento automatico di costrutti End;Modifica impostazioni di riformattazione;Modifica modalità struttura;Inserimento automatico di membri Interface e MustOverride;Mostra o nascondi separatori di riga routine;Attiva o disattiva i suggerimenti per la correzione degli errori;Attiva o disattiva l'evidenziazione di riferimenti e parole chiave;Regex;Colora espressioni regolari;Evidenzia i componenti correlati sotto il cursore;Segnala espressioni regolari non valide;regex;espressione regolare;Usa colori migliorati;Combinazione colori editor;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ja.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ja.xlf
index ef4ff8eaf0481..a9e2a1ad494ea 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ja.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ja.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">インラインのヒントを表示する;コンストラクトの終端の自動挿入;再フォーマット設定の変更;アウトライン モードの変更;Interface と MustOverride メンバーの自動挿入;プロシージャ行の区切り記号の表示/非表示;エラー修正候補のオン/オフの切り替え;参照とキーワードの強調表示のオン/オフの切り替え;Regex;正規表現の色付け;カーソルの下の関連コンポーネントの強調表示;無効な正規表現の報告;Regex;正規表現;拡張された色を使用する;エディターの配色;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ko.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ko.xlf
index 995463caa041e..ff9afb9de86da 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ko.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ko.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">인라인 힌트 표시; 맺음 구문 자동 삽입; 자동 서식 지정 설정 변경; 개요 모드 변경; 인터페이스 및 MustOverride 멤버 자동 삽입; 프로시저 줄 구분 기호 표시/숨기기; 오류 수정 제안 설정/해제; 참조 및 키워드 강조 표시 설정/해제; Regex; 정규식 색 지정; 커서 아래의 관련 구성 요소 강조 표시; 잘못된 정규식 보고; regex; 정규식; 향상된 색 사용; 편집기 색 구성표;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pl.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pl.xlf
index 4d3ce46f9c81d..454538178e9a0 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pl.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pl.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">Wyświetlaj wskazówki w tekście;Automatyczne wstawianie konstrukcji końcowych;Zmień ustawienia formatowania kodu;Zmień tryb konspektu;Automatyczne wstawianie składowych Interface i MustOverride;Pokaż lub ukryj separatory wierszy procedury;Włącz lub wyłącz sugestie dotyczące poprawy błędów;Włącz lub wyłącz wyróżnianie odwołań i słów kluczowych;Wyrażenie regularne;Koloruj wyrażenia regularne;Wyróżnij pokrewne składniki wskazane przez kursor;Zgłaszaj nieprawidłowe wyrażenia regularne;wyrażenie regularne;wyrażenie regularne;Użyj ulepszonych kolorów;Schemat kolorów edytora;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pt-BR.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pt-BR.xlf
index 4b0ae56e9e10a..fa9542d479d66 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pt-BR.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pt-BR.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">Exibir as dicas embutidas;Inserção automática de constructos finais;Alterar as configurações de reformatação automática;Alterar o modo de estrutura de tópicos;Inserção automática dos membros Interface e MustOverride;Mostrar ou ocultar os separadores de linha de procedimento;Ativar ou desativar as sugestões para correção de erros;Ativar ou desativar o realce de referências e palavras-chave;Regex;Colorir as expressões regulares;Realçar os componentes relacionados sob o cursor;Relatar as expressões regulares inválidas;regex;expressão regular;Usar cores avançadas;Esquema de Cores do Editor;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ru.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ru.xlf
index e2c1bf83adf60..145b6d4db2350 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ru.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ru.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">Отображать встроенные подсказки;Автоматическая вставка конечных конструкций;Изменение параметров автоматического форматирования;Изменение режима структуры;Автоматическая вставка интерфейса и элементов MustOverride;Отображение или скрытие разделителей строк для процедуры;Включение или отключение предложений об исправлении ошибок;Включение или отключение выделения ссылок и ключевых слов;Регулярные выражения;Выделение регулярных выражений цветом;Выделение связанных компонентов под курсором;Выделение недопустимых регулярных выражений;регулярное выражение;регулярное выражение;Использование расширенных цветов;Цветовая схема редактора;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.tr.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.tr.xlf
index 602652766f332..4c2ed918a7510 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.tr.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.tr.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">Satır içi ipuçlarını göster;Bitiş yapılarının otomatik olarak eklenmesi;Düzgün listeleme ayarlarını değiştir;Ana hat modunu değiştir;Interface ve MustOverride üyelerinin otomatik olarak eklenmesi;Yordam satır ayıraçlarını göster veya gizle;Hata düzeltme önerilerini aç veya kapat;Başvuruları ve anahtar sözcükleri vurgulamayı aç veya kapat;Normal ifade;Normal ifadeleri renklendir;İmlecin altındaki ilgili bileşenleri vurgula;Geçersiz normal ifadeleri bildir;normal ifade;normal ifade;Gelişmiş renkleri kullan;Düzenleyici Renk Düzeni;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hans.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hans.xlf
index da83604bde627..bd6c97c23ba89 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hans.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hans.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">显示内联提示;自动插入 End 构造;更改整齐排列设置;更改大纲模式;自动插入 Interface 和 MustOverride 成员;显示或隐藏过程行分隔符;打开或关闭错误纠正建议;打开或关闭引用和关键字的突出显示;正则表达式;对正则表达式着色;突出显示光标下的相关部分;报告无效正则表达式;regex;正则表达式;使用增强色;编辑器配色方案;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hant.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hant.xlf
index dc7fa458309bf..906a7cf8f668a 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hant.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hant.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
         <target state="needs-review-translation">顯示內嵌提示;自動插入 End 建構;變更美化列表設定;變更大綱模式;自動插入 Interface 和 MustOverride 成員;顯示或隱藏程序行分隔符號;開啟或關閉錯誤修正建議;開啟或關閉參考及關鍵字的醒目提示;Regex;為規則運算式著色;醒目提示游標下的相關元件;回報無效的規則運算式;regex;規則運算式;使用進階色彩;編輯器色彩配置;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/Xaml/Impl/Features/Completion/XamlCompletionItem.cs b/src/VisualStudio/Xaml/Impl/Features/Completion/XamlCompletionItem.cs
index ad73ad856d6f6..1cc5c40758609 100644
--- a/src/VisualStudio/Xaml/Impl/Features/Completion/XamlCompletionItem.cs
+++ b/src/VisualStudio/Xaml/Impl/Features/Completion/XamlCompletionItem.cs
@@ -27,5 +27,6 @@ internal class XamlCompletionItem
         public ISymbol Symbol { get; set; }
         public XamlEventDescription? EventDescription { get; set; }
         public bool RetriggerCompletion { get; set; }
+        public bool IsSnippet { get; set; }
     }
 }
diff --git a/src/VisualStudio/Xaml/Impl/Implementation/LanguageClient/XamlInProcLanguageClient.cs b/src/VisualStudio/Xaml/Impl/Implementation/LanguageClient/XamlInProcLanguageClient.cs
index 963f50ff8340e..e33d35d4b7478 100644
--- a/src/VisualStudio/Xaml/Impl/Implementation/LanguageClient/XamlInProcLanguageClient.cs
+++ b/src/VisualStudio/Xaml/Impl/Implementation/LanguageClient/XamlInProcLanguageClient.cs
@@ -46,6 +46,7 @@ public XamlInProcLanguageClient(
 
         /// <summary>
         /// Gets the name of the language client (displayed in yellow bars).
+        /// When updating the string of Name, please make sure to update the same string in Microsoft.VisualStudio.LanguageServer.Client.ExperimentalSnippetSupport.AllowList
         /// </summary>
         public override string Name => "XAML Language Server Client (Experimental)";
 
diff --git a/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Extensions/SymbolExtensions.cs b/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Extensions/SymbolExtensions.cs
index b183d296c2521..1ce359f667596 100644
--- a/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Extensions/SymbolExtensions.cs
+++ b/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Extensions/SymbolExtensions.cs
@@ -62,8 +62,10 @@ public static async Task<IEnumerable<TaggedText>> GetDescriptionAsync(this ISymb
                 {
                     builder.AddLineBreak();
                 }
+
                 builder.AddRange(section.TaggedParts);
             }
+
             return builder.ToImmutableArray();
         }
     }
diff --git a/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Completion/CompletionHandler.cs b/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Completion/CompletionHandler.cs
index 99027afb1a00b..444f6c1d4cb5d 100644
--- a/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Completion/CompletionHandler.cs
+++ b/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Completion/CompletionHandler.cs
@@ -93,6 +93,7 @@ private static CompletionItem CreateCompletionItem(XamlCompletionItem xamlComple
                 Kind = GetItemKind(xamlCompletion.Kind),
                 Description = xamlCompletion.Description,
                 Icon = xamlCompletion.Icon,
+                InsertTextFormat = xamlCompletion.IsSnippet ? InsertTextFormat.Snippet : InsertTextFormat.Plaintext,
                 Data = new CompletionResolveData { ProjectGuid = documentId.ProjectId.Id, DocumentGuid = documentId.Id, Position = position, DisplayText = xamlCompletion.DisplayText }
             };
 
diff --git a/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Hover/HoverHandler.cs b/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Hover/HoverHandler.cs
index 98f87af0d5eac..a97a6e68b2293 100644
--- a/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Hover/HoverHandler.cs
+++ b/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Hover/HoverHandler.cs
@@ -70,6 +70,7 @@ public HoverHandler()
                     {
                         descriptionBuilder.AddLineBreak();
                     }
+
                     descriptionBuilder.AddRange(description);
                 }
             }
diff --git a/src/VisualStudio/Xaml/Impl/Implementation/XamlProjectService.cs b/src/VisualStudio/Xaml/Impl/Implementation/XamlProjectService.cs
index 6ee869523c794..4e2281b555d67 100644
--- a/src/VisualStudio/Xaml/Impl/Implementation/XamlProjectService.cs
+++ b/src/VisualStudio/Xaml/Impl/Implementation/XamlProjectService.cs
@@ -80,6 +80,7 @@ public XamlProjectService(
             {
                 _documentIds.TryAdd(filePath, documentId);
             }
+
             return documentId;
 
             DocumentId? GetDocumentId(string path)
@@ -202,6 +203,7 @@ private void OnDocumentClosed(object sender, DocumentEventArgs e)
                     var project = _xamlProjects.Values.SingleOrDefault(p => p.Id == document.Project.Id);
                     project?.RemoveSourceFile(document.FilePath);
                 }
+
                 _documentIds.TryRemove(filePath, out _);
             }
         }
diff --git a/src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/DiscardSyntaxClassifier.cs b/src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/DiscardSyntaxClassifier.cs
index 91be6c144caa2..23493dc55e668 100644
--- a/src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/DiscardSyntaxClassifier.cs
+++ b/src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/DiscardSyntaxClassifier.cs
@@ -42,6 +42,7 @@ public override void AddClassifications(
                     {
                         result.Add(new ClassifiedSpan(parameter.Identifier.Span, ClassificationTypeNames.Keyword));
                     }
+
                     break;
 
                 case IdentifierNameSyntax identifierName when identifierName.Identifier.Text == "_":
@@ -51,6 +52,7 @@ public override void AddClassifications(
                     {
                         result.Add(new ClassifiedSpan(syntax.Span, ClassificationTypeNames.Keyword));
                     }
+
                     break;
             }
         }
diff --git a/src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/NameSyntaxClassifier.cs b/src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/NameSyntaxClassifier.cs
index badd7591a6ec2..f236e3444876a 100644
--- a/src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/NameSyntaxClassifier.cs
+++ b/src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/NameSyntaxClassifier.cs
@@ -212,6 +212,7 @@ private static bool TryClassifySymbol(
                         classifiedSpan = new ClassifiedSpan(token.Span, classification);
                         return true;
                     }
+
                     break;
 
                 case IFieldSymbol fieldSymbol:
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
index b2f0ab1bfc4b1..ceaff08c190dc 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
@@ -854,6 +854,7 @@ private EnumMemberDeclarationSyntax AsEnumMember(SyntaxNode node)
                         var vd = fd.Declaration.Variables[0];
                         return (EnumMemberDeclarationSyntax)this.EnumMember(vd.Identifier.ToString(), vd.Initializer?.Value);
                     }
+
                     break;
             }
 
@@ -1067,6 +1068,7 @@ public override IReadOnlyList<SyntaxNode> GetAttributeArguments(SyntaxNode attri
                     {
                         return this.GetAttributeArguments(list.Attributes[0]);
                     }
+
                     break;
                 case SyntaxKind.Attribute:
                     var attr = (AttributeSyntax)attributeDeclaration;
@@ -1074,6 +1076,7 @@ public override IReadOnlyList<SyntaxNode> GetAttributeArguments(SyntaxNode attri
                     {
                         return attr.ArgumentList.Arguments;
                     }
+
                     break;
             }
 
@@ -1113,6 +1116,7 @@ private static AttributeArgumentListSyntax GetAttributeArgumentList(SyntaxNode d
                     {
                         return list.Attributes[0].ArgumentList;
                     }
+
                     break;
                 case SyntaxKind.Attribute:
                     var attr = (AttributeSyntax)declaration;
@@ -1132,6 +1136,7 @@ private static SyntaxNode WithAttributeArgumentList(SyntaxNode declaration, Attr
                     {
                         return ReplaceWithTrivia(declaration, list.Attributes[0], list.Attributes[0].WithArgumentList(argList));
                     }
+
                     break;
                 case SyntaxKind.Attribute:
                     var attr = (AttributeSyntax)declaration;
@@ -1240,6 +1245,7 @@ private static ImmutableArray<SyntaxNode> Flatten(IEnumerable<SyntaxNode> declar
                         {
                             builder.Add(attrList);
                         }
+
                         break;
 
                     default:
@@ -1832,6 +1838,7 @@ public override SyntaxNode GetType(SyntaxNode declaration)
                     {
                         return this.GetType(declaration.Parent);
                     }
+
                     break;
             }
 
@@ -1879,6 +1886,7 @@ private SyntaxNode AsIsolatedDeclaration(SyntaxNode declaration)
                         {
                             return this.AsIsolatedDeclaration(vd.Parent);
                         }
+
                         break;
 
                     case SyntaxKind.VariableDeclarator:
@@ -1887,6 +1895,7 @@ private SyntaxNode AsIsolatedDeclaration(SyntaxNode declaration)
                         {
                             return this.ClearTrivia(WithVariable(v.Parent.Parent, v));
                         }
+
                         break;
 
                     case SyntaxKind.Attribute:
@@ -1896,6 +1905,7 @@ private SyntaxNode AsIsolatedDeclaration(SyntaxNode declaration)
                             var attrList = (AttributeListSyntax)attr.Parent;
                             return attrList.WithAttributes(SyntaxFactory.SingletonSeparatedList(attr)).WithTarget(null);
                         }
+
                         break;
                 }
             }
@@ -1955,6 +1965,7 @@ private static SyntaxNode GetFullDeclaration(SyntaxNode declaration)
                     {
                         return GetFullDeclaration(declaration.Parent);
                     }
+
                     break;
             }
 
@@ -1976,6 +1987,7 @@ private SyntaxNode AsNodeLike(SyntaxNode existingNode, SyntaxNode newNode)
                     {
                         return this.AsMemberOf(container, newNode);
                     }
+
                     break;
 
                 case DeclarationKind.Attribute:
@@ -2104,6 +2116,9 @@ private static SyntaxNode WithParameterList(SyntaxNode declaration, BaseParamete
                             .WithLeadingTrivia(lambda.GetLeadingTrivia())
                             .WithTrailingTrivia(lambda.GetTrailingTrivia());
                     }
+                case SyntaxKind.RecordDeclaration:
+                case SyntaxKind.RecordStructDeclaration:
+                    return ((RecordDeclarationSyntax)declaration).WithParameterList((ParameterListSyntax)list);
                 default:
                     return declaration;
             }
@@ -2124,6 +2139,7 @@ public override SyntaxNode GetExpression(SyntaxNode declaration)
                     {
                         return pd.ExpressionBody.Expression;
                     }
+
                     goto default;
 
                 case SyntaxKind.IndexerDeclaration:
@@ -2132,6 +2148,7 @@ public override SyntaxNode GetExpression(SyntaxNode declaration)
                     {
                         return id.ExpressionBody.Expression;
                     }
+
                     goto default;
 
                 case SyntaxKind.MethodDeclaration:
@@ -2140,6 +2157,7 @@ public override SyntaxNode GetExpression(SyntaxNode declaration)
                     {
                         return method.ExpressionBody.Expression;
                     }
+
                     goto default;
 
                 case SyntaxKind.LocalFunctionStatement:
@@ -2148,6 +2166,7 @@ public override SyntaxNode GetExpression(SyntaxNode declaration)
                     {
                         return local.ExpressionBody.Expression;
                     }
+
                     goto default;
 
                 default:
@@ -2176,6 +2195,7 @@ private static SyntaxNode WithExpressionInternal(SyntaxNode declaration, SyntaxN
                     {
                         return ReplaceWithTrivia(pd, pd.ExpressionBody.Expression, expr);
                     }
+
                     goto default;
 
                 case SyntaxKind.IndexerDeclaration:
@@ -2184,6 +2204,7 @@ private static SyntaxNode WithExpressionInternal(SyntaxNode declaration, SyntaxN
                     {
                         return ReplaceWithTrivia(id, id.ExpressionBody.Expression, expr);
                     }
+
                     goto default;
 
                 case SyntaxKind.MethodDeclaration:
@@ -2192,6 +2213,7 @@ private static SyntaxNode WithExpressionInternal(SyntaxNode declaration, SyntaxN
                     {
                         return ReplaceWithTrivia(method, method.ExpressionBody.Expression, expr);
                     }
+
                     goto default;
 
                 case SyntaxKind.LocalFunctionStatement:
@@ -2200,6 +2222,7 @@ private static SyntaxNode WithExpressionInternal(SyntaxNode declaration, SyntaxN
                     {
                         return ReplaceWithTrivia(local, local.ExpressionBody.Expression, expr);
                     }
+
                     goto default;
 
                 default:
@@ -2237,6 +2260,7 @@ private static EqualsValueClauseSyntax GetEqualsValue(SyntaxNode declaration)
                     {
                         return fd.Declaration.Variables[0].Initializer;
                     }
+
                     break;
                 case SyntaxKind.PropertyDeclaration:
                     var pd = (PropertyDeclarationSyntax)declaration;
@@ -2247,6 +2271,7 @@ private static EqualsValueClauseSyntax GetEqualsValue(SyntaxNode declaration)
                     {
                         return ld.Declaration.Variables[0].Initializer;
                     }
+
                     break;
                 case SyntaxKind.VariableDeclaration:
                     var vd = (VariableDeclarationSyntax)declaration;
@@ -2254,6 +2279,7 @@ private static EqualsValueClauseSyntax GetEqualsValue(SyntaxNode declaration)
                     {
                         return vd.Variables[0].Initializer;
                     }
+
                     break;
                 case SyntaxKind.VariableDeclarator:
                     return ((VariableDeclaratorSyntax)declaration).Initializer;
@@ -2274,6 +2300,7 @@ private static SyntaxNode WithEqualsValue(SyntaxNode declaration, EqualsValueCla
                     {
                         return ReplaceWithTrivia(declaration, fd.Declaration.Variables[0], fd.Declaration.Variables[0].WithInitializer(eq));
                     }
+
                     break;
                 case SyntaxKind.PropertyDeclaration:
                     var pd = (PropertyDeclarationSyntax)declaration;
@@ -2284,6 +2311,7 @@ private static SyntaxNode WithEqualsValue(SyntaxNode declaration, EqualsValueCla
                     {
                         return ReplaceWithTrivia(declaration, ld.Declaration.Variables[0], ld.Declaration.Variables[0].WithInitializer(eq));
                     }
+
                     break;
                 case SyntaxKind.VariableDeclaration:
                     var vd = (VariableDeclarationSyntax)declaration;
@@ -2291,6 +2319,7 @@ private static SyntaxNode WithEqualsValue(SyntaxNode declaration, EqualsValueCla
                     {
                         return ReplaceWithTrivia(declaration, vd.Variables[0], vd.Variables[0].WithInitializer(eq));
                     }
+
                     break;
                 case SyntaxKind.VariableDeclarator:
                     return ((VariableDeclaratorSyntax)declaration).WithInitializer(eq);
@@ -2435,6 +2464,7 @@ private static AccessorDeclarationSyntax AsAccessor(SyntaxNode node, SyntaxKind
                         case SyntaxKind.SetAccessorDeclaration:
                             return (AccessorDeclarationSyntax)node;
                     }
+
                     break;
                 case SyntaxKind.EventDeclaration:
                     switch (node.Kind())
@@ -2443,6 +2473,7 @@ private static AccessorDeclarationSyntax AsAccessor(SyntaxNode node, SyntaxKind
                         case SyntaxKind.RemoveAccessorDeclaration:
                             return (AccessorDeclarationSyntax)node;
                     }
+
                     break;
             }
 
@@ -2846,6 +2877,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                         // remove entire list if only one attribute
                         return this.RemoveNodeInternal(root, attrList, options);
                     }
+
                     break;
 
                 case SyntaxKind.AttributeArgument:
@@ -2854,6 +2886,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                         // remove entire argument list if only one argument
                         return this.RemoveNodeInternal(root, declaration.Parent, options);
                     }
+
                     break;
 
                 case SyntaxKind.VariableDeclarator:
@@ -2863,6 +2896,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                         // remove full declaration if only one declarator
                         return this.RemoveNodeInternal(root, full, options);
                     }
+
                     break;
 
                 case SyntaxKind.SimpleBaseType:
@@ -2871,6 +2905,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                         // remove entire base list if this is the only base type.
                         return this.RemoveNodeInternal(root, baseList, options);
                     }
+
                     break;
 
                 default:
@@ -2883,6 +2918,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                                 return this.RemoveNodeInternal(root, parent, options);
                         }
                     }
+
                     break;
             }
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
index bf8f904398b2b..451fb52bf6cdf 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
@@ -220,9 +220,14 @@ private static SyntaxTokenList GenerateModifiers(
         {
             var tokens = ArrayBuilder<SyntaxToken>.GetInstance();
 
-            // Only "unsafe" modifier allowed if we're an explicit impl.
+            // Only "static" and "unsafe" modifiers allowed if we're an explicit impl.
             if (method.ExplicitInterfaceImplementations.Any())
             {
+                if (method.IsStatic)
+                {
+                    tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
+                }
+
                 if (CodeGenerationMethodInfo.GetIsUnsafe(method))
                 {
                     tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword));
@@ -237,6 +242,11 @@ private static SyntaxTokenList GenerateModifiers(
                 {
                     AddAccessibilityModifiers(method.DeclaredAccessibility, tokens, options, Accessibility.Private);
 
+                    if (method.IsStatic)
+                    {
+                        tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
+                    }
+
                     if (method.IsAbstract)
                     {
                         tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
@@ -247,11 +257,6 @@ private static SyntaxTokenList GenerateModifiers(
                         tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword));
                     }
 
-                    if (method.IsStatic)
-                    {
-                        tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
-                    }
-
                     // Don't show the readonly modifier if the containing type is already readonly
                     // ContainingSymbol is used to guard against methods which are not members of their ContainingType (e.g. lambdas and local functions)
                     if (method.IsReadOnly && (method.ContainingSymbol as INamedTypeSymbol)?.IsReadOnly != true)
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/OperatorGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/OperatorGenerator.cs
index 819a5ab6d9bed..570cdbf4041d7 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/OperatorGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/OperatorGenerator.cs
@@ -10,7 +10,8 @@
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-
+using Microsoft.CodeAnalysis.Shared.Collections;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using static Microsoft.CodeAnalysis.CodeGeneration.CodeGenerationHelpers;
 using static Microsoft.CodeAnalysis.CSharp.CodeGeneration.CSharpCodeGenerationHelpers;
 
@@ -74,7 +75,7 @@ private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker(
             CodeGenerationOptions options,
             ParseOptions parseOptions)
         {
-            var hasNoBody = !options.GenerateMethodBodies || method.IsExtern;
+            var hasNoBody = !options.GenerateMethodBodies || method.IsExtern || method.IsAbstract;
 
             var operatorSyntaxKind = SyntaxFacts.GetOperatorKind(method.MetadataName);
             if (operatorSyntaxKind == SyntaxKind.None)
@@ -86,23 +87,37 @@ private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker(
 
             var operatorDecl = SyntaxFactory.OperatorDeclaration(
                 attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), options),
-                modifiers: GenerateModifiers(),
+                modifiers: GenerateModifiers(method),
                 returnType: method.ReturnType.GenerateTypeSyntax(),
+                explicitInterfaceSpecifier: GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations),
                 operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
                 operatorToken: operatorToken,
                 parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, isExplicit: false, options: options),
                 body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
+                expressionBody: null,
                 semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken());
 
             operatorDecl = UseExpressionBodyIfDesired(options, operatorDecl, parseOptions);
             return operatorDecl;
         }
 
-        private static SyntaxTokenList GenerateModifiers()
+        private static SyntaxTokenList GenerateModifiers(IMethodSymbol method)
         {
-            return SyntaxFactory.TokenList(
-                SyntaxFactory.Token(SyntaxKind.PublicKeyword),
-                SyntaxFactory.Token(SyntaxKind.StaticKeyword));
+            using var tokens = TemporaryArray<SyntaxToken>.Empty;
+
+            if (method.ExplicitInterfaceImplementations.Length == 0)
+            {
+                tokens.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
+            }
+
+            tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
+
+            if (method.IsAbstract)
+            {
+                tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
+            }
+
+            return tokens.ToImmutableAndClear().ToSyntaxTokenList();
         }
     }
 }
diff --git a/src/Workspaces/CSharp/Portable/FindSymbols/CSharpDeclaredSymbolInfoFactoryService.cs b/src/Workspaces/CSharp/Portable/FindSymbols/CSharpDeclaredSymbolInfoFactoryService.cs
index 73116e2bd4528..040d4ad5fef1f 100644
--- a/src/Workspaces/CSharp/Portable/FindSymbols/CSharpDeclaredSymbolInfoFactoryService.cs
+++ b/src/Workspaces/CSharp/Portable/FindSymbols/CSharpDeclaredSymbolInfoFactoryService.cs
@@ -11,6 +11,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
@@ -24,7 +25,13 @@
 namespace Microsoft.CodeAnalysis.CSharp.FindSymbols
 {
     [ExportLanguageService(typeof(IDeclaredSymbolInfoFactoryService), LanguageNames.CSharp), Shared]
-    internal class CSharpDeclaredSymbolInfoFactoryService : AbstractDeclaredSymbolInfoFactoryService
+    internal class CSharpDeclaredSymbolInfoFactoryService : AbstractDeclaredSymbolInfoFactoryService<
+        CompilationUnitSyntax,
+        UsingDirectiveSyntax,
+        NamespaceDeclarationSyntax,
+        TypeDeclarationSyntax,
+        EnumDeclarationSyntax,
+        MemberDeclarationSyntax>
     {
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
@@ -147,7 +154,16 @@ private static void AddInheritanceName(
             }
         }
 
-        public override bool TryGetDeclaredSymbolInfo(StringTable stringTable, SyntaxNode node, string rootNamespace, out DeclaredSymbolInfo declaredSymbolInfo)
+        protected override void AddDeclaredSymbolInfosWorker(
+            SyntaxNode container,
+            MemberDeclarationSyntax node,
+            StringTable stringTable,
+            ArrayBuilder<DeclaredSymbolInfo> declaredSymbolInfos,
+            Dictionary<string, string> aliases,
+            Dictionary<string, ArrayBuilder<int>> extensionMethodInfo,
+            string containerDisplayName,
+            string fullyQualifiedContainerName,
+            CancellationToken cancellationToken)
         {
             // If this is a part of partial type that only contains nested types, then we don't make an info type for
             // it. That's because we effectively think of this as just being a virtual container just to hold the nested
@@ -158,8 +174,7 @@ public override bool TryGetDeclaredSymbolInfo(StringTable stringTable, SyntaxNod
                 typeDeclaration.Members.Any() &&
                 typeDeclaration.Members.All(m => m is BaseTypeDeclarationSyntax))
             {
-                declaredSymbolInfo = default;
-                return false;
+                return;
             }
 
             switch (node.Kind())
@@ -170,12 +185,12 @@ public override bool TryGetDeclaredSymbolInfo(StringTable stringTable, SyntaxNod
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.StructDeclaration:
                     var typeDecl = (TypeDeclarationSyntax)node;
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         typeDecl.Identifier.ValueText,
                         GetTypeParameterSuffix(typeDecl.TypeParameterList),
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         typeDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
                         node.Kind() switch
                         {
@@ -186,126 +201,128 @@ public override bool TryGetDeclaredSymbolInfo(StringTable stringTable, SyntaxNod
                             SyntaxKind.RecordStructDeclaration => DeclaredSymbolInfoKind.RecordStruct,
                             _ => throw ExceptionUtilities.UnexpectedValue(node.Kind()),
                         },
-                        GetAccessibility(typeDecl, typeDecl.Modifiers),
+                        GetAccessibility(container, typeDecl.Modifiers),
                         typeDecl.Identifier.Span,
                         GetInheritanceNames(stringTable, typeDecl.BaseList),
-                        IsNestedType(typeDecl));
-                    return true;
+                        IsNestedType(typeDecl)));
+                    return;
                 case SyntaxKind.EnumDeclaration:
                     var enumDecl = (EnumDeclarationSyntax)node;
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         enumDecl.Identifier.ValueText, null,
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         enumDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Enum,
-                        GetAccessibility(enumDecl, enumDecl.Modifiers),
+                        GetAccessibility(container, enumDecl.Modifiers),
                         enumDecl.Identifier.Span,
                         inheritanceNames: ImmutableArray<string>.Empty,
-                        isNestedType: IsNestedType(enumDecl));
-                    return true;
+                        isNestedType: IsNestedType(enumDecl)));
+                    return;
                 case SyntaxKind.ConstructorDeclaration:
                     var ctorDecl = (ConstructorDeclarationSyntax)node;
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         ctorDecl.Identifier.ValueText,
                         GetConstructorSuffix(ctorDecl),
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         ctorDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Constructor,
-                        GetAccessibility(ctorDecl, ctorDecl.Modifiers),
+                        GetAccessibility(container, ctorDecl.Modifiers),
                         ctorDecl.Identifier.Span,
                         inheritanceNames: ImmutableArray<string>.Empty,
-                        parameterCount: ctorDecl.ParameterList?.Parameters.Count ?? 0);
-                    return true;
+                        parameterCount: ctorDecl.ParameterList?.Parameters.Count ?? 0));
+                    return;
                 case SyntaxKind.DelegateDeclaration:
                     var delegateDecl = (DelegateDeclarationSyntax)node;
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         delegateDecl.Identifier.ValueText,
                         GetTypeParameterSuffix(delegateDecl.TypeParameterList),
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         delegateDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Delegate,
-                        GetAccessibility(delegateDecl, delegateDecl.Modifiers),
+                        GetAccessibility(container, delegateDecl.Modifiers),
                         delegateDecl.Identifier.Span,
-                        inheritanceNames: ImmutableArray<string>.Empty);
-                    return true;
+                        inheritanceNames: ImmutableArray<string>.Empty));
+                    return;
                 case SyntaxKind.EnumMemberDeclaration:
                     var enumMember = (EnumMemberDeclarationSyntax)node;
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         enumMember.Identifier.ValueText, null,
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         enumMember.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.EnumMember,
                         Accessibility.Public,
                         enumMember.Identifier.Span,
-                        inheritanceNames: ImmutableArray<string>.Empty);
-                    return true;
+                        inheritanceNames: ImmutableArray<string>.Empty));
+                    return;
                 case SyntaxKind.EventDeclaration:
                     var eventDecl = (EventDeclarationSyntax)node;
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         eventDecl.Identifier.ValueText, null,
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         eventDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Event,
-                        GetAccessibility(eventDecl, eventDecl.Modifiers),
+                        GetAccessibility(container, eventDecl.Modifiers),
                         eventDecl.Identifier.Span,
-                        inheritanceNames: ImmutableArray<string>.Empty);
-                    return true;
+                        inheritanceNames: ImmutableArray<string>.Empty));
+                    return;
                 case SyntaxKind.IndexerDeclaration:
                     var indexerDecl = (IndexerDeclarationSyntax)node;
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         "this", GetIndexerSuffix(indexerDecl),
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         indexerDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Indexer,
-                        GetAccessibility(indexerDecl, indexerDecl.Modifiers),
+                        GetAccessibility(container, indexerDecl.Modifiers),
                         indexerDecl.ThisKeyword.Span,
-                        inheritanceNames: ImmutableArray<string>.Empty);
-                    return true;
+                        inheritanceNames: ImmutableArray<string>.Empty));
+                    return;
                 case SyntaxKind.MethodDeclaration:
                     var method = (MethodDeclarationSyntax)node;
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    var isExtensionMethod = IsExtensionMethod(method);
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         method.Identifier.ValueText, GetMethodSuffix(method),
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         method.Modifiers.Any(SyntaxKind.PartialKeyword),
-                        IsExtensionMethod(method) ? DeclaredSymbolInfoKind.ExtensionMethod : DeclaredSymbolInfoKind.Method,
-                        GetAccessibility(method, method.Modifiers),
+                        isExtensionMethod ? DeclaredSymbolInfoKind.ExtensionMethod : DeclaredSymbolInfoKind.Method,
+                        GetAccessibility(container, method.Modifiers),
                         method.Identifier.Span,
                         inheritanceNames: ImmutableArray<string>.Empty,
                         parameterCount: method.ParameterList?.Parameters.Count ?? 0,
-                        typeParameterCount: method.TypeParameterList?.Parameters.Count ?? 0);
-                    return true;
+                        typeParameterCount: method.TypeParameterList?.Parameters.Count ?? 0));
+                    if (isExtensionMethod)
+                        AddExtensionMethodInfo(method, aliases, declaredSymbolInfos.Count - 1, extensionMethodInfo);
+                    return;
                 case SyntaxKind.PropertyDeclaration:
                     var property = (PropertyDeclarationSyntax)node;
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         property.Identifier.ValueText, null,
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         property.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Property,
-                        GetAccessibility(property, property.Modifiers),
+                        GetAccessibility(container, property.Modifiers),
                         property.Identifier.Span,
-                        inheritanceNames: ImmutableArray<string>.Empty);
-                    return true;
-                case SyntaxKind.VariableDeclarator:
-                    // could either be part of a field declaration or an event field declaration
-                    var variableDeclarator = (VariableDeclaratorSyntax)node;
-                    var variableDeclaration = variableDeclarator.Parent as VariableDeclarationSyntax;
-                    if (variableDeclaration?.Parent is BaseFieldDeclarationSyntax fieldDeclaration)
+                        inheritanceNames: ImmutableArray<string>.Empty));
+                    return;
+                case SyntaxKind.FieldDeclaration:
+                case SyntaxKind.EventFieldDeclaration:
+                    var fieldDeclaration = (BaseFieldDeclarationSyntax)node;
+                    foreach (var variableDeclarator in fieldDeclaration.Declaration.Variables)
                     {
                         var kind = fieldDeclaration is EventFieldDeclarationSyntax
                             ? DeclaredSymbolInfoKind.Event
@@ -313,26 +330,40 @@ public override bool TryGetDeclaredSymbolInfo(StringTable stringTable, SyntaxNod
                                 ? DeclaredSymbolInfoKind.Constant
                                 : DeclaredSymbolInfoKind.Field;
 
-                        declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                        declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                             stringTable,
                             variableDeclarator.Identifier.ValueText, null,
-                            GetContainerDisplayName(fieldDeclaration.Parent),
-                            GetFullyQualifiedContainerName(fieldDeclaration.Parent),
+                            containerDisplayName,
+                            fullyQualifiedContainerName,
                             fieldDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword),
                             kind,
-                            GetAccessibility(fieldDeclaration, fieldDeclaration.Modifiers),
+                            GetAccessibility(container, fieldDeclaration.Modifiers),
                             variableDeclarator.Identifier.Span,
-                            inheritanceNames: ImmutableArray<string>.Empty);
-                        return true;
+                            inheritanceNames: ImmutableArray<string>.Empty));
                     }
 
-                    break;
+                    return;
             }
-
-            declaredSymbolInfo = default;
-            return false;
         }
 
+        protected override SyntaxList<MemberDeclarationSyntax> GetChildren(CompilationUnitSyntax node)
+            => node.Members;
+
+        protected override SyntaxList<MemberDeclarationSyntax> GetChildren(NamespaceDeclarationSyntax node)
+            => node.Members;
+
+        protected override SyntaxList<MemberDeclarationSyntax> GetChildren(TypeDeclarationSyntax node)
+            => node.Members;
+
+        protected override IEnumerable<MemberDeclarationSyntax> GetChildren(EnumDeclarationSyntax node)
+            => node.Members;
+
+        protected override SyntaxList<UsingDirectiveSyntax> GetUsingAliases(CompilationUnitSyntax node)
+            => node.Usings;
+
+        protected override SyntaxList<UsingDirectiveSyntax> GetUsingAliases(NamespaceDeclarationSyntax node)
+            => node.Usings;
+
         private static bool IsNestedType(BaseTypeDeclarationSyntax typeDecl)
             => typeDecl.Parent is BaseTypeDeclarationSyntax;
 
@@ -432,13 +463,13 @@ private static void AppendParameters(SeparatedSyntaxList<ParameterSyntax> parame
             }
         }
 
-        private static string GetContainerDisplayName(SyntaxNode node)
+        protected override string GetContainerDisplayName(MemberDeclarationSyntax node)
             => CSharpSyntaxFacts.Instance.GetDisplayName(node, DisplayNameOptions.IncludeTypeParameters);
 
-        private static string GetFullyQualifiedContainerName(SyntaxNode node)
+        protected override string GetFullyQualifiedContainerName(MemberDeclarationSyntax node, string rootNamespace)
             => CSharpSyntaxFacts.Instance.GetDisplayName(node, DisplayNameOptions.IncludeNamespaces);
 
-        private static Accessibility GetAccessibility(SyntaxNode node, SyntaxTokenList modifiers)
+        private static Accessibility GetAccessibility(SyntaxNode container, SyntaxTokenList modifiers)
         {
             var sawInternal = false;
             foreach (var modifier in modifiers)
@@ -455,12 +486,10 @@ private static Accessibility GetAccessibility(SyntaxNode node, SyntaxTokenList m
             }
 
             if (sawInternal)
-            {
                 return Accessibility.Internal;
-            }
 
             // No accessibility modifiers:
-            switch (node.Parent.Kind())
+            switch (container.Kind())
             {
                 case SyntaxKind.ClassDeclaration:
                 case SyntaxKind.RecordDeclaration:
@@ -473,10 +502,8 @@ private static Accessibility GetAccessibility(SyntaxNode node, SyntaxTokenList m
                     return Accessibility.Public;
                 case SyntaxKind.CompilationUnit:
                     // Things are private by default in script
-                    if (((CSharpParseOptions)node.SyntaxTree.Options).Kind == SourceCodeKind.Script)
-                    {
+                    if (((CSharpParseOptions)container.SyntaxTree.Options).Kind == SourceCodeKind.Script)
                         return Accessibility.Private;
-                    }
 
                     return Accessibility.Internal;
 
@@ -512,12 +539,13 @@ private static bool IsExtensionMethod(MethodDeclarationSyntax method)
                method.ParameterList.Parameters[0].Modifiers.Any(SyntaxKind.ThisKeyword);
 
         // Root namespace is a VB only concept, which basically means root namespace is always global in C#.
-        public override string GetRootNamespace(CompilationOptions compilationOptions)
+        protected override string GetRootNamespace(CompilationOptions compilationOptions)
             => string.Empty;
 
-        public override bool TryGetAliasesFromUsingDirective(SyntaxNode node, out ImmutableArray<(string aliasName, string name)> aliases)
+        protected override bool TryGetAliasesFromUsingDirective(
+            UsingDirectiveSyntax usingDirectiveNode, out ImmutableArray<(string aliasName, string name)> aliases)
         {
-            if (node is UsingDirectiveSyntax usingDirectiveNode && usingDirectiveNode.Alias != null)
+            if (usingDirectiveNode.Alias != null)
             {
                 if (TryGetSimpleTypeName(usingDirectiveNode.Alias.Name, typeParameterNames: null, out var aliasName, out _) &&
                     TryGetSimpleTypeName(usingDirectiveNode.Name, typeParameterNames: null, out var name, out _))
@@ -531,7 +559,7 @@ public override bool TryGetAliasesFromUsingDirective(SyntaxNode node, out Immuta
             return false;
         }
 
-        public override string GetReceiverTypeName(SyntaxNode node)
+        protected override string GetReceiverTypeName(MemberDeclarationSyntax node)
         {
             var methodDeclaration = (MethodDeclarationSyntax)node;
             Debug.Assert(IsExtensionMethod(methodDeclaration));
@@ -562,7 +590,7 @@ private static bool TryGetSimpleTypeName(SyntaxNode node, ImmutableArray<string>
                     case GenericNameSyntax genericNameNode:
                         var name = genericNameNode.Identifier.Text;
                         var arity = genericNameNode.Arity;
-                        simpleTypeName = arity == 0 ? name : name + GetMetadataAritySuffix(arity);
+                        simpleTypeName = arity == 0 ? name : name + ArityUtilities.GetMetadataAritySuffix(arity);
                         return true;
 
                     case PredefinedTypeSyntax predefinedTypeNode:
diff --git a/src/Workspaces/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Workspaces.csproj b/src/Workspaces/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Workspaces.csproj
index fad332e9ccc56..7f3239d0f5526 100644
--- a/src/Workspaces/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Workspaces.csproj
+++ b/src/Workspaces/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Workspaces.csproj
@@ -6,7 +6,7 @@
     <RootNamespace>Microsoft.CodeAnalysis.CSharp</RootNamespace>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TargetFrameworks>netcoreapp3.1;netstandard2.0</TargetFrameworks>
-    <ApplyNgenOptimization>partial</ApplyNgenOptimization>
+    <ApplyNgenOptimization Condition="'$(TargetFramework)' == 'netstandard2.0'">partial</ApplyNgenOptimization>
 
     <!-- NuGet -->
     <IsPackable>true</IsPackable>
diff --git a/src/Workspaces/CSharp/Portable/Recommendations/CSharpRecommendationServiceRunner.cs b/src/Workspaces/CSharp/Portable/Recommendations/CSharpRecommendationServiceRunner.cs
index c123818fa2c9e..7e11abc057cee 100644
--- a/src/Workspaces/CSharp/Portable/Recommendations/CSharpRecommendationServiceRunner.cs
+++ b/src/Workspaces/CSharp/Portable/Recommendations/CSharpRecommendationServiceRunner.cs
@@ -256,7 +256,7 @@ private RecommendedSymbols GetSymbolsOffOfName(NameSyntax name)
             }
 
             if (ShouldBeTreatedAsTypeInsteadOfExpression(name, out var nameBinding, out var container))
-                return GetSymbolsOffOfBoundExpression(name, name, nameBinding, container);
+                return GetSymbolsOffOfBoundExpression(name, name, nameBinding, container, unwrapNullable: false);
 
             // We're in a name-only context, since if we were an expression we'd be a
             // MemberAccessExpressionSyntax. Thus, let's do other namespaces and types.
@@ -353,14 +353,14 @@ private RecommendedSymbols GetSymbolsOffOfExpression(ExpressionSyntax? originalE
             var leftHandBinding = _context.SemanticModel.GetSymbolInfo(expression, _cancellationToken);
             var container = _context.SemanticModel.GetTypeInfo(expression, _cancellationToken).Type;
 
-            var result = GetSymbolsOffOfBoundExpression(originalExpression, expression, leftHandBinding, container);
+            var result = GetSymbolsOffOfBoundExpression(originalExpression, expression, leftHandBinding, container, unwrapNullable: false);
 
             // Check for the Color Color case.
             if (originalExpression.CanAccessInstanceAndStaticMembersOffOf(_context.SemanticModel, _cancellationToken))
             {
                 var speculativeSymbolInfo = _context.SemanticModel.GetSpeculativeSymbolInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsTypeOrNamespace);
 
-                var typeMembers = GetSymbolsOffOfBoundExpression(originalExpression, expression, speculativeSymbolInfo, container);
+                var typeMembers = GetSymbolsOffOfBoundExpression(originalExpression, expression, speculativeSymbolInfo, container, unwrapNullable: false);
 
                 result = new RecommendedSymbols(
                     result.NamedSymbols.Concat(typeMembers.NamedSymbols),
@@ -381,7 +381,7 @@ private RecommendedSymbols GetSymbolsOffOfDereferencedExpression(ExpressionSynta
                 container = pointerType.PointedAtType;
             }
 
-            return GetSymbolsOffOfBoundExpression(originalExpression, expression, leftHandBinding, container);
+            return GetSymbolsOffOfBoundExpression(originalExpression, expression, leftHandBinding, container, unwrapNullable: false);
         }
 
         private RecommendedSymbols GetSymbolsOffOfConditionalReceiver(ExpressionSyntax originalExpression)
@@ -392,22 +392,24 @@ private RecommendedSymbols GetSymbolsOffOfConditionalReceiver(ExpressionSyntax o
 
             var expression = originalExpression.WalkDownParentheses();
             var leftHandBinding = _context.SemanticModel.GetSymbolInfo(expression, _cancellationToken);
-            var container = _context.SemanticModel.GetTypeInfo(expression, _cancellationToken).Type.RemoveNullableIfPresent();
+            var container = _context.SemanticModel.GetTypeInfo(expression, _cancellationToken).Type;
 
             // If the thing on the left is a type, namespace, or alias, we shouldn't show anything in
             // IntelliSense.
             if (leftHandBinding.GetBestOrAllSymbols().FirstOrDefault().MatchesKind(SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Alias))
                 return default;
 
-            return GetSymbolsOffOfBoundExpression(originalExpression, expression, leftHandBinding, container);
+            return GetSymbolsOffOfBoundExpression(originalExpression, expression, leftHandBinding, container, unwrapNullable: true);
         }
 
         private RecommendedSymbols GetSymbolsOffOfBoundExpression(
             ExpressionSyntax originalExpression,
             ExpressionSyntax expression,
             SymbolInfo leftHandBinding,
-            ITypeSymbol? containerType)
+            ITypeSymbol? containerType,
+            bool unwrapNullable)
         {
+            var abstractsOnly = false;
             var excludeInstance = false;
             var excludeStatic = true;
 
@@ -447,12 +449,14 @@ private RecommendedSymbols GetSymbolsOffOfBoundExpression(
                 if (symbol is IAliasSymbol alias)
                     symbol = alias.Target;
 
-                if (symbol.Kind is SymbolKind.NamedType or SymbolKind.Namespace)
+                if (symbol.Kind is SymbolKind.NamedType or SymbolKind.Namespace or SymbolKind.TypeParameter)
                 {
-                    // For named typed and namespaces, we flip things around.  We only want statics and not instance members.
+                    // For named typed, namespaces, and type parameters (potentially constrainted to interface with statics), we flip things around.
+                    // We only want statics and not instance members.
                     excludeInstance = true;
                     excludeStatic = false;
-                    containerSymbol = (INamespaceOrTypeSymbol)symbol;
+                    abstractsOnly = symbol.Kind == SymbolKind.TypeParameter;
+                    containerSymbol = symbol;
                 }
 
                 // Special case parameters. If we have a normal (non this/base) parameter, then that's what we want to
@@ -479,6 +483,7 @@ private RecommendedSymbols GetSymbolsOffOfBoundExpression(
                 return default;
 
             Debug.Assert(!excludeInstance || !excludeStatic);
+            Debug.Assert(!abstractsOnly || (abstractsOnly && !excludeStatic && excludeInstance));
 
             // nameof(X.|
             // Show static and instance members.
@@ -489,12 +494,12 @@ private RecommendedSymbols GetSymbolsOffOfBoundExpression(
             }
 
             var useBaseReferenceAccessibility = symbol is IParameterSymbol { IsThis: true } p && !p.Type.Equals(containerType);
-            var symbols = GetMemberSymbols(containerSymbol, position: originalExpression.SpanStart, excludeInstance, useBaseReferenceAccessibility);
+            var symbols = GetMemberSymbols(containerSymbol, position: originalExpression.SpanStart, excludeInstance, useBaseReferenceAccessibility, unwrapNullable);
 
             // If we're showing instance members, don't include nested types
             var namedSymbols = excludeStatic
                 ? symbols.WhereAsArray(s => !(s.IsStatic || s is ITypeSymbol))
-                : symbols;
+                : (abstractsOnly ? symbols.WhereAsArray(s => s.IsAbstract) : symbols);
 
             // if we're dotting off an instance, then add potential operators/indexers/conversions that may be
             // applicable to it as well.
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.Expander.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.Expander.cs
index e8cf99794241c..bf8c370f9fb1e 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.Expander.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.Expander.cs
@@ -308,6 +308,7 @@ private static bool CanMakeNameExplicitInTuple(TupleExpressionSyntax tuple, stri
                             // No duplicate names allowed
                             return false;
                         }
+
                         found = true;
                     }
                 }
@@ -502,6 +503,7 @@ private ExpressionSyntax VisitSimpleName(SimpleNameSyntax rewrittenSimpleName, S
                                 {
                                     replacement = replacement.ReplaceToken(firstOriginalToken, tokenWithLeadingWhitespace);
                                 }
+
                                 break;
 
                             case SyntaxKind.QualifiedName:
diff --git a/src/Workspaces/CSharp/Portable/Workspace/LanguageServices/CSharpCompilationFactoryService.cs b/src/Workspaces/CSharp/Portable/Workspace/LanguageServices/CSharpCompilationFactoryService.cs
index 00f5e22c59bb6..13d91d5fff3c6 100644
--- a/src/Workspaces/CSharp/Portable/Workspace/LanguageServices/CSharpCompilationFactoryService.cs
+++ b/src/Workspaces/CSharp/Portable/Workspace/LanguageServices/CSharpCompilationFactoryService.cs
@@ -41,7 +41,7 @@ Compilation ICompilationFactoryService.CreateSubmissionCompilation(string assemb
         CompilationOptions ICompilationFactoryService.GetDefaultCompilationOptions()
             => s_defaultOptions;
 
-        GeneratorDriver? ICompilationFactoryService.CreateGeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider optionsProvider, ImmutableArray<AdditionalText> additionalTexts)
+        GeneratorDriver ICompilationFactoryService.CreateGeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider optionsProvider, ImmutableArray<AdditionalText> additionalTexts)
         {
             return CSharpGeneratorDriver.Create(generators, additionalTexts, (CSharpParseOptions)parseOptions, optionsProvider);
         }
diff --git a/src/Workspaces/CSharpTest/CodeGeneration/AddImportsTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/AddImportsTests.cs
index 3c7f46870cf5c..6cd7faf6edc63 100644
--- a/src/Workspaces/CSharpTest/CodeGeneration/AddImportsTests.cs
+++ b/src/Workspaces/CSharpTest/CodeGeneration/AddImportsTests.cs
@@ -51,6 +51,7 @@ private static async Task<Document> GetDocument(string code, bool withAnnotation
                     });
                 doc = doc.WithSyntaxRoot(root);
             }
+
             return doc;
         }
 
diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs b/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
index 68247fc533965..85ba35de37291 100644
--- a/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
+++ b/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
@@ -9028,6 +9028,7 @@ static string transform(string s)
                         lines[i] = new string(' ', count: 8) + lines[i];
                     }
                 }
+
                 return string.Join(Environment.NewLine, lines);
             }
 
@@ -10021,5 +10022,82 @@ record struct R(int X);
 record  struct  R(int X);
 ");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public async Task LambdaReturnType_01()
+        {
+            await AssertFormatAsync(
+@"class Program
+{
+    Delegate D = void () => { };
+}",
+@"class Program
+{
+    Delegate D = void  ()  =>  {  };
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public async Task LambdaReturnType_02()
+        {
+            await AssertFormatAsync(
+@"class Program
+{
+    Delegate D = A.B () => { };
+}",
+@"class Program
+{
+    Delegate D = A.B()=>{  };
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public async Task LambdaReturnType_03()
+        {
+            await AssertFormatAsync(
+@"class Program
+{
+    Delegate D = A<B> (x) => x;
+}",
+@"class Program
+{
+    Delegate D = A < B >  ( x ) => x;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public async Task LambdaReturnType_04()
+        {
+            await AssertFormatAsync(
+@"class Program
+{
+    object F = Func((A, B) ((A, B) t) => t);
+}",
+@"class Program
+{
+    object F = Func((A,B)((A,B)t)=>t);
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public async Task LineSpanDirective()
+        {
+            var optionSet = new OptionsCollection(LanguageNames.CSharp) { { FormattingOptions2.UseTabs, true } };
+            await AssertFormatAsync(
+@"class Program
+{
+	static void Main()
+	{
+#line (1, 1) - (1, 100) 5 ""a.razor""
+	}
+}",
+@"class Program
+{
+    static void Main()
+    {
+#line (1,1)-(1,100) 5 ""a.razor""
+    }
+}", changedOptionSet: optionSet);
+        }
     }
 }
diff --git a/src/Workspaces/Core/MSBuild/MSBuild/Build/ProjectBuildManager.cs b/src/Workspaces/Core/MSBuild/MSBuild/Build/ProjectBuildManager.cs
index f1c98c4de478f..d08e55cfcf188 100644
--- a/src/Workspaces/Core/MSBuild/MSBuild/Build/ProjectBuildManager.cs
+++ b/src/Workspaces/Core/MSBuild/MSBuild/Build/ProjectBuildManager.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.Worker_ResolveReferences.cs b/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.Worker_ResolveReferences.cs
index cd64608f7bc44..5b1c167ea3511 100644
--- a/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.Worker_ResolveReferences.cs
+++ b/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.Worker_ResolveReferences.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.cs b/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.cs
index ad504f88f359a..2f323d373ff82 100644
--- a/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.cs
+++ b/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Workspaces/Core/MSBuild/MSBuild/MSBuildWorkspace.cs b/src/Workspaces/Core/MSBuild/MSBuild/MSBuildWorkspace.cs
index 10e91ddd6ad76..dba94bbc991dd 100644
--- a/src/Workspaces/Core/MSBuild/MSBuild/MSBuildWorkspace.cs
+++ b/src/Workspaces/Core/MSBuild/MSBuild/MSBuildWorkspace.cs
@@ -327,6 +327,7 @@ protected override void ApplyProjectChanges(ProjectChanges projectChanges)
                                                                projectChanges.ProjectId));
                         return;
                     }
+
                     if (_projectFileLoaderRegistry.TryGetLoaderFromProjectPath(projectPath, out var fileLoader))
                     {
                         try
@@ -375,6 +376,7 @@ protected override void ApplyDocumentTextChanged(DocumentId documentId, SourceTe
                     _reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, message, document.Id));
                     return;
                 }
+
                 this.SaveDocumentText(documentId, document.FilePath, text, encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
                 this.OnDocumentTextChanged(documentId, text, PreservationMode.PreserveValue);
             }
@@ -392,6 +394,7 @@ protected override void ApplyAdditionalDocumentTextChanged(DocumentId documentId
                     _reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, message, document.Id));
                     return;
                 }
+
                 this.SaveDocumentText(documentId, document.FilePath, text, encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
                 this.OnAdditionalDocumentTextChanged(documentId, text, PreservationMode.PreserveValue);
             }
@@ -435,6 +438,7 @@ protected override void ApplyDocumentAdded(DocumentInfo info, SourceText text)
             {
                 return;
             }
+
             if (_projectFileLoaderRegistry.TryGetLoaderFromProjectPath(filePath, out _))
             {
                 var extension = _applyChangesProjectFile.GetDocumentExtension(info.SourceCodeKind);
@@ -530,6 +534,7 @@ protected override void ApplyMetadataReferenceAdded(ProjectId projectId, Metadat
                 _reporter.Report(new ProjectDiagnostic(WorkspaceDiagnosticKind.Failure, message, projectId));
                 return;
             }
+
             _applyChangesProjectFile.AddMetadataReference(metadataReference, identity);
             this.OnMetadataReferenceAdded(projectId, metadataReference);
         }
@@ -544,6 +549,7 @@ protected override void ApplyMetadataReferenceRemoved(ProjectId projectId, Metad
                 _reporter.Report(new ProjectDiagnostic(WorkspaceDiagnosticKind.Failure, message, projectId));
                 return;
             }
+
             _applyChangesProjectFile.RemoveMetadataReference(metadataReference, identity);
             this.OnMetadataReferenceRemoved(projectId, metadataReference);
         }
@@ -555,6 +561,7 @@ protected override void ApplyMetadataReferenceRemoved(ProjectId projectId, Metad
             {
                 return null;
             }
+
             if (!project.MetadataReferences.Contains(metadataReference))
             {
                 project = project.AddMetadataReference(metadataReference);
@@ -565,6 +572,7 @@ protected override void ApplyMetadataReferenceRemoved(ProjectId projectId, Metad
             {
                 return null;
             }
+
             var symbol = compilation.GetAssemblyOrModuleSymbol(metadataReference) as IAssemblySymbol;
             return symbol?.Identity;
         }
diff --git a/src/Workspaces/Core/MSBuild/MSBuild/ProjectFile/Extensions.cs b/src/Workspaces/Core/MSBuild/MSBuild/ProjectFile/Extensions.cs
index eec1823393a06..a21ee61b0a180 100644
--- a/src/Workspaces/Core/MSBuild/MSBuild/ProjectFile/Extensions.cs
+++ b/src/Workspaces/Core/MSBuild/MSBuild/ProjectFile/Extensions.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Workspaces/Core/MSBuild/MSBuild/ProjectMap.cs b/src/Workspaces/Core/MSBuild/MSBuild/ProjectMap.cs
index cae640133d341..242809c13f33d 100644
--- a/src/Workspaces/Core/MSBuild/MSBuild/ProjectMap.cs
+++ b/src/Workspaces/Core/MSBuild/MSBuild/ProjectMap.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
diff --git a/src/Workspaces/Core/Portable/Diagnostics/DiagnosticMode.cs b/src/Workspaces/Core/Portable/Diagnostics/DiagnosticMode.cs
index b89e97ed48f7e..f6b0e621d2fe3 100644
--- a/src/Workspaces/Core/Portable/Diagnostics/DiagnosticMode.cs
+++ b/src/Workspaces/Core/Portable/Diagnostics/DiagnosticMode.cs
@@ -16,5 +16,11 @@ internal enum DiagnosticMode
         /// responding to LSP pull requests for them.
         /// </summary>
         Pull,
+
+        /// <summary>
+        /// Default mode - when the option is set to default we use a feature flag to determine if we're
+        /// is in <see cref="Push"/> or <see cref="Pull"/>
+        /// </summary>
+        Default,
     }
 }
diff --git a/src/Workspaces/Core/Portable/Diagnostics/InternalDiagnosticsOptions.cs b/src/Workspaces/Core/Portable/Diagnostics/InternalDiagnosticsOptions.cs
index 78b72e5c5264c..69b8e43985984 100644
--- a/src/Workspaces/Core/Portable/Diagnostics/InternalDiagnosticsOptions.cs
+++ b/src/Workspaces/Core/Portable/Diagnostics/InternalDiagnosticsOptions.cs
@@ -25,7 +25,7 @@ internal static class InternalDiagnosticsOptions
         public static readonly Option2<bool> ProcessHiddenDiagnostics = new(nameof(InternalDiagnosticsOptions), nameof(ProcessHiddenDiagnostics), defaultValue: false,
             storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "Process Hidden Diagnostics"));
 
-        public static readonly Option2<DiagnosticMode> NormalDiagnosticMode = new(nameof(InternalDiagnosticsOptions), nameof(NormalDiagnosticMode), defaultValue: DiagnosticMode.Push,
+        public static readonly Option2<DiagnosticMode> NormalDiagnosticMode = new(nameof(InternalDiagnosticsOptions), nameof(NormalDiagnosticMode), defaultValue: DiagnosticMode.Default,
             storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + "NormalDiagnosticMode"));
 
         public static readonly Option2<DiagnosticMode> RazorDiagnosticMode = new(nameof(InternalDiagnosticsOptions), nameof(RazorDiagnosticMode), defaultValue: DiagnosticMode.Pull,
diff --git a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
index 0c35682d73566..3b2a04d15f6eb 100644
--- a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
+++ b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
@@ -577,6 +577,7 @@ public SyntaxNode Declaration(ISymbol symbol)
                         case MethodKind.UserDefinedOperator:
                             return OperatorDeclaration(method);
                     }
+
                     break;
 
                 case SymbolKind.Parameter:
@@ -661,6 +662,7 @@ private static bool CanBeDeclared(ISymbol symbol)
                         case MethodKind.Ordinary:
                             return true;
                     }
+
                     break;
 
                 case SymbolKind.NamedType:
@@ -674,6 +676,7 @@ private static bool CanBeDeclared(ISymbol symbol)
                         case TypeKind.Delegate:
                             return true;
                     }
+
                     break;
             }
 
diff --git a/src/Workspaces/Core/Portable/Experiments/IExperimentationService.cs b/src/Workspaces/Core/Portable/Experiments/IExperimentationService.cs
index 881f40c78a723..f120570649767 100644
--- a/src/Workspaces/Core/Portable/Experiments/IExperimentationService.cs
+++ b/src/Workspaces/Core/Portable/Experiments/IExperimentationService.cs
@@ -41,5 +41,7 @@ internal static class WellKnownExperimentNames
         public const string CloudCache = "Roslyn.CloudCache";
         public const string UnnamedSymbolCompletionDisabled = "Roslyn.UnnamedSymbolCompletionDisabled";
         public const string RazorLspEditorFeatureFlag = "Razor.LSP.Editor";
+        public const string InheritanceMargin = "Roslyn.InheritanceMargin";
+        public const string LspPullDiagnosticsFeatureFlag = "Lsp.PullDiagnostics";
     }
 }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.cs
index 69f4306df840d..3c47abb899ef1 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
@@ -16,7 +17,7 @@
 
 namespace Microsoft.CodeAnalysis.FindSymbols
 {
-    using ProjectToDocumentMap = Dictionary<Project, Dictionary<Document, HashSet<(SymbolGroup group, ISymbol symbol, IReferenceFinder finder)>>>;
+    using ProjectToDocumentMap = Dictionary<Project, Dictionary<Document, HashSet<ISymbol>>>;
 
     internal partial class FindReferencesSearchEngine
     {
@@ -34,6 +35,8 @@ internal partial class FindReferencesSearchEngine
         private readonly TaskScheduler _scheduler;
         private static readonly TaskScheduler s_exclusiveScheduler = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler;
 
+        private readonly ConcurrentDictionary<ISymbol, SymbolGroup> _symbolToGroup = new();
+
         public FindReferencesSearchEngine(
             Solution solution,
             IImmutableSet<Document>? documents,
@@ -108,7 +111,7 @@ private async Task ProcessAsync(ProjectToDocumentMap projectToDocumentMap, Cance
         private static void ValidateProjectToDocumentMap(
             ProjectToDocumentMap projectToDocumentMap)
         {
-            var set = new HashSet<(SymbolGroup group, ISymbol symbol, IReferenceFinder finder)>();
+            var set = new HashSet<ISymbol>();
 
             foreach (var documentMap in projectToDocumentMap.Values)
             {
@@ -122,7 +125,33 @@ private static void ValidateProjectToDocumentMap(
             }
         }
 
-        private ValueTask HandleLocationAsync(SymbolGroup group, ISymbol symbol, ReferenceLocation location, CancellationToken cancellationToken)
-            => _progress.OnReferenceFoundAsync(group, symbol, location, cancellationToken);
+        private async ValueTask HandleLocationAsync(ISymbol symbol, ReferenceLocation location, CancellationToken cancellationToken)
+        {
+            var group = await GetOrCreateSymbolGroupAsync(symbol, cancellationToken).ConfigureAwait(false);
+            await _progress.OnReferenceFoundAsync(group, symbol, location, cancellationToken).ConfigureAwait(false);
+        }
+
+        private async ValueTask<SymbolGroup> GetOrCreateSymbolGroupAsync(ISymbol symbol, CancellationToken cancellationToken)
+        {
+            // See if this symbol is already associated with a symbol group.
+            if (!_symbolToGroup.TryGetValue(symbol, out var group))
+            {
+                // If not, compute the group it should be associated with.
+                group = await DetermineSymbolGroupAsync(symbol, cancellationToken).ConfigureAwait(false);
+
+                // now try to update our mapping.
+                lock (_symbolToGroup)
+                {
+                    // Another thread may have beat us, so only do this if we're actually the first to get here.
+                    if (!_symbolToGroup.TryGetValue(symbol, out _))
+                    {
+                        foreach (var groupSymbol in group.Symbols)
+                            Contract.ThrowIfFalse(_symbolToGroup.TryAdd(groupSymbol, group));
+                    }
+                }
+            }
+
+            return group;
+        }
     }
 }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_DocumentProcessing.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_DocumentProcessing.cs
index 9ea4179095976..7c570a68dbe33 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_DocumentProcessing.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_DocumentProcessing.cs
@@ -16,7 +16,7 @@ internal partial class FindReferencesSearchEngine
     {
         private async Task ProcessDocumentQueueAsync(
             Document document,
-            HashSet<(SymbolGroup group, ISymbol symbol, IReferenceFinder finder)> documentQueue,
+            HashSet<ISymbol> documentQueue,
             CancellationToken cancellationToken)
         {
             await _progress.OnFindInDocumentStartedAsync(document, cancellationToken).ConfigureAwait(false);
@@ -29,8 +29,8 @@ private async Task ProcessDocumentQueueAsync(
                 // start cache for this semantic model
                 FindReferenceCache.Start(model);
 
-                foreach (var (group, symbol, finder) in documentQueue)
-                    await ProcessDocumentAsync(document, model, group, symbol, finder, cancellationToken).ConfigureAwait(false);
+                foreach (var symbol in documentQueue)
+                    await ProcessDocumentAsync(document, model, symbol, cancellationToken).ConfigureAwait(false);
             }
             finally
             {
@@ -48,20 +48,19 @@ private async Task ProcessDocumentQueueAsync(
         private async Task ProcessDocumentAsync(
             Document document,
             SemanticModel semanticModel,
-            SymbolGroup group,
             ISymbol symbol,
-            IReferenceFinder finder,
             CancellationToken cancellationToken)
         {
             using (Logger.LogBlock(FunctionId.FindReference_ProcessDocumentAsync, s_logDocument, document, symbol, cancellationToken))
             {
                 try
                 {
-                    var references = await finder.FindReferencesInDocumentAsync(
-                        symbol, document, semanticModel, _options, cancellationToken).ConfigureAwait(false);
-                    foreach (var (_, location) in references)
+                    foreach (var finder in _finders)
                     {
-                        await HandleLocationAsync(group, symbol, location, cancellationToken).ConfigureAwait(false);
+                        var references = await finder.FindReferencesInDocumentAsync(
+                            symbol, document, semanticModel, _options, cancellationToken).ConfigureAwait(false);
+                        foreach (var (_, location) in references)
+                            await HandleLocationAsync(symbol, location, cancellationToken).ConfigureAwait(false);
                     }
                 }
                 finally
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_MapCreation.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_MapCreation.cs
index 47010180cdfcb..b04db155d06db 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_MapCreation.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_MapCreation.cs
@@ -17,9 +17,9 @@
 
 namespace Microsoft.CodeAnalysis.FindSymbols
 {
-    using DocumentMap = Dictionary<Document, HashSet<(SymbolGroup group, ISymbol symbol, IReferenceFinder finder)>>;
-    using ProjectMap = Dictionary<Project, HashSet<(SymbolGroup group, ISymbol symbol, IReferenceFinder finder)>>;
-    using ProjectToDocumentMap = Dictionary<Project, Dictionary<Document, HashSet<(SymbolGroup group, ISymbol symbol, IReferenceFinder finder)>>>;
+    using DocumentMap = Dictionary<Document, HashSet<ISymbol>>;
+    using ProjectMap = Dictionary<Project, HashSet<ISymbol>>;
+    using ProjectToDocumentMap = Dictionary<Project, Dictionary<Document, HashSet<ISymbol>>>;
 
     internal partial class FindReferencesSearchEngine
     {
@@ -29,26 +29,26 @@ private async Task<ProjectToDocumentMap> CreateProjectToDocumentMapAsync(Project
         {
             using (Logger.LogBlock(FunctionId.FindReference_CreateDocumentMapAsync, cancellationToken))
             {
-                using var _ = ArrayBuilder<Task<(ImmutableArray<Document>, SymbolGroup, ISymbol, IReferenceFinder)>>.GetInstance(out var tasks);
+                using var _ = ArrayBuilder<Task<(ImmutableArray<Document>, ISymbol)>>.GetInstance(out var tasks);
 
                 foreach (var (project, projectQueue) in projectMap)
                 {
-                    foreach (var (group, symbol, finder) in projectQueue)
+                    foreach (var symbol in projectQueue)
                     {
                         tasks.Add(Task.Factory.StartNew(() =>
-                            DetermineDocumentsToSearchAsync(project, group, symbol, finder, cancellationToken), cancellationToken, TaskCreationOptions.None, _scheduler).Unwrap());
+                            DetermineDocumentsToSearchAsync(project, symbol, cancellationToken), cancellationToken, TaskCreationOptions.None, _scheduler).Unwrap());
                     }
                 }
 
                 var results = await Task.WhenAll(tasks).ConfigureAwait(false);
 
                 var finalMap = new ProjectToDocumentMap();
-                foreach (var (documents, group, symbol, finder) in results)
+                foreach (var (documents, symbol) in results)
                 {
                     foreach (var document in documents)
                     {
                         finalMap.GetOrAdd(document.Project, s_createDocumentMap)
-                                .MultiAdd(document, (group, symbol, finder));
+                                .MultiAdd(document, symbol);
                     }
                 }
 
@@ -63,14 +63,25 @@ private async Task<ProjectToDocumentMap> CreateProjectToDocumentMapAsync(Project
             }
         }
 
-        private async Task<(ImmutableArray<Document>, SymbolGroup, ISymbol, IReferenceFinder)> DetermineDocumentsToSearchAsync(
-            Project project, SymbolGroup group, ISymbol symbol, IReferenceFinder finder, CancellationToken cancellationToken)
+        private async Task<(ImmutableArray<Document>, ISymbol)> DetermineDocumentsToSearchAsync(
+            Project project, ISymbol symbol, CancellationToken cancellationToken)
         {
-            var documents = await finder.DetermineDocumentsToSearchAsync(
-                symbol, project, _documents, _options, cancellationToken).ConfigureAwait(false);
-            var finalDocs = documents.WhereNotNull().Distinct().Where(
-                d => _documents == null || _documents.Contains(d)).ToImmutableArray();
-            return (finalDocs, group, symbol, finder);
+            using var _ = ArrayBuilder<Document>.GetInstance(out var result);
+
+            foreach (var finder in _finders)
+            {
+                var documents = await finder.DetermineDocumentsToSearchAsync(
+                    symbol, project, _documents, _options, cancellationToken).ConfigureAwait(false);
+
+                foreach (var document in documents)
+                {
+                    if (_documents == null || _documents.Contains(document))
+                        result.Add(document);
+                }
+            }
+
+            result.RemoveDuplicates();
+            return (result.ToImmutable(), symbol);
         }
 
         private async Task<ProjectMap> CreateProjectMapAsync(ConcurrentSet<SymbolGroup> symbolGroups, CancellationToken cancellationToken)
@@ -84,16 +95,14 @@ private async Task<ProjectMap> CreateProjectMapAsync(ConcurrentSet<SymbolGroup>
                 {
                     foreach (var symbol in symbolGroup.Symbols)
                     {
-                        foreach (var finder in _finders)
+                        cancellationToken.ThrowIfCancellationRequested();
+                        var projects = await DependentProjectsFinder.GetDependentProjectsAsync(
+                            _solution, symbol, scope, cancellationToken).ConfigureAwait(false);
+
+                        foreach (var project in projects.Distinct().WhereNotNull())
                         {
-                            cancellationToken.ThrowIfCancellationRequested();
-
-                            var projects = await finder.DetermineProjectsToSearchAsync(symbol, _solution, scope, cancellationToken).ConfigureAwait(false);
-                            foreach (var project in projects.Distinct().WhereNotNull())
-                            {
-                                if (scope == null || scope.Contains(project))
-                                    projectMap.MultiAdd(project, (symbolGroup, symbol, finder));
-                            }
+                            if (scope == null || scope.Contains(project))
+                                projectMap.MultiAdd(project, symbol);
                         }
                     }
                 }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_ProjectProcessing.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_ProjectProcessing.cs
index c1db21f5f435a..a6b0c28a10bd6 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_ProjectProcessing.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_ProjectProcessing.cs
@@ -6,13 +6,13 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.FindSymbols.Finders;
 using Microsoft.CodeAnalysis.Internal.Log;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.FindSymbols
 {
-    using DocumentMap = Dictionary<Document, HashSet<(SymbolGroup group, ISymbol symbol, IReferenceFinder finder)>>;
+    using DocumentMap = Dictionary<Document, HashSet<ISymbol>>;
 
     internal partial class FindReferencesSearchEngine
     {
@@ -28,7 +28,7 @@ private async Task ProcessProjectAsync(
                     // make sure we hold onto compilation while we search documents belong to this project
                     var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
 
-                    var documentTasks = new List<Task>();
+                    using var _ = ArrayBuilder<Task>.GetInstance(out var documentTasks);
                     foreach (var (document, documentQueue) in documentMap)
                     {
                         if (document.Project == project)
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractMethodOrPropertyOrEventSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractMethodOrPropertyOrEventSymbolReferenceFinder.cs
index 4b2948900236d..29e40ca4a9817 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractMethodOrPropertyOrEventSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractMethodOrPropertyOrEventSymbolReferenceFinder.cs
@@ -26,10 +26,6 @@ protected AbstractMethodOrPropertyOrEventSymbolReferenceFinder()
             FindReferencesCascadeDirection cascadeDirection,
             CancellationToken cancellationToken)
         {
-            // Static methods can't cascade.
-            if (symbol.IsStatic)
-                return ImmutableArray<(ISymbol symbol, FindReferencesCascadeDirection cascadeDirection)>.Empty;
-
             if (symbol.IsImplementableMember())
             {
                 // We have an interface method.  Walk down the inheritance hierarchy and find all implementations of
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs
index 113ff4ff76f93..8fbffac24712f 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs
@@ -31,8 +31,6 @@ internal abstract partial class AbstractReferenceFinder : IReferenceFinder
             FindReferencesSearchOptions options, FindReferencesCascadeDirection cascadeDirection,
             CancellationToken cancellationToken);
 
-        public abstract Task<ImmutableArray<Project>> DetermineProjectsToSearchAsync(ISymbol symbol, Solution solution, IImmutableSet<Project>? projects, CancellationToken cancellationToken);
-
         public abstract Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
             ISymbol symbol, Project project, IImmutableSet<Document>? documents, FindReferencesSearchOptions options, CancellationToken cancellationToken);
 
@@ -85,18 +83,12 @@ protected static async Task<ImmutableArray<Document>> FindDocumentsAsync(Project
         protected static Task<ImmutableArray<Document>> FindDocumentsAsync(
             Project project,
             IImmutableSet<Document>? documents,
-            bool findInGlobalSuppressions,
             CancellationToken cancellationToken,
             params string[] values)
         {
             return FindDocumentsAsync(project, documents, async (d, c) =>
             {
                 var info = await SyntaxTreeIndex.GetRequiredIndexAsync(d, c).ConfigureAwait(false);
-                if (findInGlobalSuppressions && info.ContainsGlobalAttributes)
-                {
-                    return true;
-                }
-
                 foreach (var value in values)
                 {
                     if (!info.ProbablyContainsIdentifier(value))
@@ -109,6 +101,21 @@ protected static Task<ImmutableArray<Document>> FindDocumentsAsync(
             }, cancellationToken);
         }
 
+        /// <summary>
+        /// Finds all the documents in the provided project that contain a global attribute in them.
+        /// </summary>
+        protected static Task<ImmutableArray<Document>> FindDocumentsWithGlobalAttributesAsync(
+            Project project,
+            IImmutableSet<Document>? documents,
+            CancellationToken cancellationToken)
+        {
+            return FindDocumentsAsync(project, documents, async (d, c) =>
+            {
+                var info = await SyntaxTreeIndex.GetRequiredIndexAsync(d, c).ConfigureAwait(false);
+                return info.ContainsGlobalAttributes;
+            }, cancellationToken);
+        }
+
         protected static Task<ImmutableArray<Document>> FindDocumentsAsync(
             Project project,
             IImmutableSet<Document>? documents,
@@ -134,22 +141,19 @@ protected static Task<ImmutableArray<Document>> FindDocumentsAsync(
             CancellationToken cancellationToken)
         {
             if (op == PredefinedOperator.None)
-            {
                 return SpecializedTasks.EmptyImmutableArray<Document>();
-            }
 
             return FindDocumentsAsync(project, documents, async (d, c) =>
             {
                 var info = await SyntaxTreeIndex.GetRequiredIndexAsync(d, c).ConfigureAwait(false);
-
-                // NOTE: Predefined operators can be referenced in global suppression attributes.
-                return info.ContainsPredefinedOperator(op) || info.ContainsGlobalAttributes;
+                return info.ContainsPredefinedOperator(op);
             }, cancellationToken);
         }
 
         protected static bool IdentifiersMatch(ISyntaxFactsService syntaxFacts, string name, SyntaxToken token)
             => syntaxFacts.IsIdentifier(token) && syntaxFacts.TextMatch(token.ValueText, name);
 
+        [PerformanceSensitive("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1224834", OftenCompletesSynchronously = true)]
         protected static ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentUsingIdentifierAsync(
             ISymbol symbol,
             string identifier,
@@ -162,6 +166,7 @@ protected static ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocum
                 cancellationToken: cancellationToken);
         }
 
+        [PerformanceSensitive("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1224834", OftenCompletesSynchronously = true)]
         protected static ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentUsingIdentifierAsync(
             ISymbol symbol,
             string identifier,
@@ -175,49 +180,26 @@ protected static ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocum
                 symbol, identifier, document, semanticModel, symbolsMatch, cancellationToken);
         }
 
-        protected static ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentUsingIdentifierAsync(
-            ISymbol symbol,
-            string identifier,
-            Document document,
-            SemanticModel semanticModel,
-            Func<SyntaxToken, SemanticModel, ValueTask<(bool matched, CandidateReason reason)>> symbolsMatchAsync,
-            CancellationToken cancellationToken)
-        {
-            var findInGlobalSuppressions = ShouldFindReferencesInGlobalSuppressions(symbol, out var docCommentId);
-            return FindReferencesInDocumentUsingIdentifierAsync(
-                identifier, document, semanticModel, symbolsMatchAsync,
-                docCommentId, findInGlobalSuppressions, cancellationToken);
-        }
-
         [PerformanceSensitive("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1224834", OftenCompletesSynchronously = true)]
         protected static async ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentUsingIdentifierAsync(
+            ISymbol _,
             string identifier,
             Document document,
             SemanticModel semanticModel,
             Func<SyntaxToken, SemanticModel, ValueTask<(bool matched, CandidateReason reason)>> symbolsMatchAsync,
-            string? docCommentId,
-            bool findInGlobalSuppressions,
             CancellationToken cancellationToken)
         {
             var tokens = await GetIdentifierOrGlobalNamespaceTokensWithTextAsync(document, semanticModel, identifier, cancellationToken).ConfigureAwait(false);
 
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
 
-            var references = await FindReferencesInTokensAsync(
+            return await FindReferencesInTokensAsync(
                 document,
                 semanticModel,
                 tokens,
                 t => IdentifiersMatch(syntaxFacts, identifier, t),
                 symbolsMatchAsync,
                 cancellationToken).ConfigureAwait(false);
-
-            if (!findInGlobalSuppressions)
-                return references;
-
-            RoslynDebug.Assert(docCommentId != null);
-            var referencesInGlobalSuppressions = await FindReferencesInDocumentInsideGlobalSuppressionsAsync(
-                document, semanticModel, syntaxFacts, docCommentId, cancellationToken).ConfigureAwait(false);
-            return references.AddRange(referencesInGlobalSuppressions);
         }
 
         protected static async Task<ImmutableArray<SyntaxToken>> GetIdentifierOrGlobalNamespaceTokensWithTextAsync(Document document, SemanticModel semanticModel, string identifier, CancellationToken cancellationToken)
@@ -267,23 +249,18 @@ protected static async Task<ImmutableArray<SyntaxToken>> GetIdentifierOrGlobalNa
         {
             return async (node, model) =>
             {
-                var symbolInfoToMatch = FindReferenceCache.GetSymbolInfo(model, node, cancellationToken);
+                var symbolInfo = FindReferenceCache.GetSymbolInfo(model, node, cancellationToken);
 
-                var symbolToMatch = symbolInfoToMatch.Symbol;
-                var symbolToMatchCompilation = model.Compilation;
-
-                if (await SymbolFinder.OriginalSymbolsMatchAsync(solution, searchSymbol, symbolInfoToMatch.Symbol, cancellationToken).ConfigureAwait(false))
-                {
+                if (await SymbolFinder.OriginalSymbolsMatchAsync(solution, searchSymbol, symbolInfo.Symbol, cancellationToken).ConfigureAwait(false))
                     return (matched: true, CandidateReason.None);
-                }
-                else if (await symbolInfoToMatch.CandidateSymbols.AnyAsync(static (s, arg) => SymbolFinder.OriginalSymbolsMatchAsync(arg.solution, arg.searchSymbol, s, arg.cancellationToken), (solution, searchSymbol, cancellationToken)).ConfigureAwait(false))
-                {
-                    return (matched: true, symbolInfoToMatch.CandidateReason);
-                }
-                else
+
+                foreach (var candidate in symbolInfo.CandidateSymbols)
                 {
-                    return (matched: false, CandidateReason.None);
+                    if (await SymbolFinder.OriginalSymbolsMatchAsync(solution, searchSymbol, candidate, cancellationToken).ConfigureAwait(false))
+                        return (matched: true, symbolInfo.CandidateReason);
                 }
+
+                return default;
             };
         }
 
@@ -444,27 +421,23 @@ private static async Task<ImmutableArray<FinderLocation>> FindReferencesThroughA
             CancellationToken cancellationToken)
         {
             var syntaxFactsService = document.GetRequiredLanguageService<ISyntaxFactsService>();
-            var allAliasReferences = ArrayBuilder<FinderLocation>.GetInstance();
+            using var _ = ArrayBuilder<FinderLocation>.GetInstance(out var allAliasReferences);
             foreach (var aliasSymbol in aliasSymbols)
             {
-                var findInGlobalSuppressions = ShouldFindReferencesInGlobalSuppressions(aliasSymbol, out var docCommentId);
-
                 var aliasReferences = await FindReferencesInDocumentUsingIdentifierAsync(
-                    aliasSymbol.Name, document, semanticModel, symbolsMatchAsync,
-                    docCommentId, findInGlobalSuppressions, cancellationToken).ConfigureAwait(false);
+                    aliasSymbol, aliasSymbol.Name, document, semanticModel, symbolsMatchAsync, cancellationToken).ConfigureAwait(false);
                 allAliasReferences.AddRange(aliasReferences);
                 // the alias may reference an attribute and the alias name may end with an "Attribute" suffix. In this case search for the
                 // shortened name as well (e.g. using GooAttribute = MyNamespace.GooAttribute; [Goo] class C1 {})
                 if (TryGetNameWithoutAttributeSuffix(aliasSymbol.Name, syntaxFactsService, out var simpleName))
                 {
                     aliasReferences = await FindReferencesInDocumentUsingIdentifierAsync(
-                        simpleName, document, semanticModel, symbolsMatchAsync,
-                        docCommentId, findInGlobalSuppressions, cancellationToken).ConfigureAwait(false);
+                        aliasSymbol, simpleName, document, semanticModel, symbolsMatchAsync, cancellationToken).ConfigureAwait(false);
                     allAliasReferences.AddRange(aliasReferences);
                 }
             }
 
-            return allAliasReferences.ToImmutableAndFree();
+            return allAliasReferences.ToImmutable();
         }
 
         protected static Task<ImmutableArray<Document>> FindDocumentsWithPredicateAsync(Project project, IImmutableSet<Document>? documents, Func<SyntaxTreeIndex, bool> predicate, CancellationToken cancellationToken)
@@ -491,11 +464,11 @@ protected static Task<ImmutableArray<Document>> FindDocumentsWithImplicitObjectC
         /// <summary>
         /// If the `node` implicitly matches the `symbol`, then it will be added to `locations`.
         /// </summary>
-        protected delegate void CollectMatchingReferences(ISymbol symbol, SyntaxNode node,
-            ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations);
+        protected delegate void CollectMatchingReferences(
+            SyntaxNode node, ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations);
 
         protected static async Task<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
-            ISymbol symbol,
+            ISymbol _,
             Document document,
             Func<SyntaxTreeIndex, bool> isRelevantDocument,
             CollectMatchingReferences collectMatchingReferences,
@@ -508,14 +481,12 @@ protected static async Task<ImmutableArray<FinderLocation>> FindReferencesInDocu
                 var semanticFacts = document.GetRequiredLanguageService<ISemanticFactsService>();
                 var syntaxRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-                using var _ = ArrayBuilder<FinderLocation>.GetInstance(out var locations);
-
-                var originalUnreducedSymbolDefinition = symbol.GetOriginalUnreducedDefinition();
+                using var _1 = ArrayBuilder<FinderLocation>.GetInstance(out var locations);
 
                 foreach (var node in syntaxRoot.DescendantNodesAndSelf())
                 {
                     cancellationToken.ThrowIfCancellationRequested();
-                    collectMatchingReferences(originalUnreducedSymbolDefinition, node, syntaxFacts, semanticFacts, locations);
+                    collectMatchingReferences(node, syntaxFacts, semanticFacts, locations);
                 }
 
                 return locations.ToImmutable();
@@ -535,15 +506,15 @@ protected Task<ImmutableArray<FinderLocation>> FindReferencesInForEachStatements
             static bool IsRelevantDocument(SyntaxTreeIndex syntaxTreeInfo)
                 => syntaxTreeInfo.ContainsForEachStatement;
 
-            void CollectMatchingReferences(ISymbol originalUnreducedSymbolDefinition, SyntaxNode node,
-                ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations)
+            void CollectMatchingReferences(
+                SyntaxNode node, ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations)
             {
                 var info = semanticFacts.GetForEachSymbols(semanticModel, node);
 
-                if (Matches(info.GetEnumeratorMethod, originalUnreducedSymbolDefinition) ||
-                    Matches(info.MoveNextMethod, originalUnreducedSymbolDefinition) ||
-                    Matches(info.CurrentProperty, originalUnreducedSymbolDefinition) ||
-                    Matches(info.DisposeMethod, originalUnreducedSymbolDefinition))
+                if (Matches(info.GetEnumeratorMethod, symbol) ||
+                    Matches(info.MoveNextMethod, symbol) ||
+                    Matches(info.CurrentProperty, symbol) ||
+                    Matches(info.DisposeMethod, symbol))
                 {
                     var location = node.GetFirstToken().GetLocation();
                     var symbolUsageInfo = GetSymbolUsageInfo(node, semanticModel, syntaxFacts, semanticFacts, cancellationToken);
@@ -571,8 +542,8 @@ protected Task<ImmutableArray<FinderLocation>> FindReferencesInDeconstructionAsy
             static bool IsRelevantDocument(SyntaxTreeIndex syntaxTreeInfo)
                 => syntaxTreeInfo.ContainsDeconstruction;
 
-            void CollectMatchingReferences(ISymbol originalUnreducedSymbolDefinition, SyntaxNode node,
-                ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations)
+            void CollectMatchingReferences(
+                SyntaxNode node, ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations)
             {
                 var deconstructMethods = semanticFacts.GetDeconstructionAssignmentMethods(semanticModel, node);
                 if (deconstructMethods.IsEmpty)
@@ -581,7 +552,7 @@ void CollectMatchingReferences(ISymbol originalUnreducedSymbolDefinition, Syntax
                     deconstructMethods = semanticFacts.GetDeconstructionForEachMethods(semanticModel, node);
                 }
 
-                if (deconstructMethods.Any(m => Matches(m, originalUnreducedSymbolDefinition)))
+                if (deconstructMethods.Any(m => Matches(m, symbol)))
                 {
                     var location = syntaxFacts.GetDeconstructionReferenceLocation(node);
                     var symbolUsageInfo = GetSymbolUsageInfo(node, semanticModel, syntaxFacts, semanticFacts, cancellationToken);
@@ -603,12 +574,12 @@ protected Task<ImmutableArray<FinderLocation>> FindReferencesInAwaitExpressionAs
             static bool IsRelevantDocument(SyntaxTreeIndex syntaxTreeInfo)
                 => syntaxTreeInfo.ContainsAwait;
 
-            void CollectMatchingReferences(ISymbol originalUnreducedSymbolDefinition, SyntaxNode node,
-                ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations)
+            void CollectMatchingReferences(
+                SyntaxNode node, ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations)
             {
                 var awaitExpressionMethod = semanticFacts.GetGetAwaiterMethod(semanticModel, node);
 
-                if (Matches(awaitExpressionMethod, originalUnreducedSymbolDefinition))
+                if (Matches(awaitExpressionMethod, symbol))
                 {
                     var location = node.GetFirstToken().GetLocation();
                     var symbolUsageInfo = GetSymbolUsageInfo(node, semanticModel, syntaxFacts, semanticFacts, cancellationToken);
@@ -630,8 +601,8 @@ protected Task<ImmutableArray<FinderLocation>> FindReferencesInImplicitObjectCre
             static bool IsRelevantDocument(SyntaxTreeIndex syntaxTreeInfo)
                 => syntaxTreeInfo.ContainsImplicitObjectCreation;
 
-            void CollectMatchingReferences(ISymbol originalUnreducedSymbolDefinition, SyntaxNode node,
-                ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations)
+            void CollectMatchingReferences(
+                SyntaxNode node, ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations)
             {
                 if (!syntaxFacts.IsImplicitObjectCreation(node))
                 {
@@ -641,7 +612,7 @@ void CollectMatchingReferences(ISymbol originalUnreducedSymbolDefinition, Syntax
 
                 var constructor = semanticModel.GetSymbolInfo(node, cancellationToken).Symbol;
 
-                if (Matches(constructor, originalUnreducedSymbolDefinition))
+                if (Matches(constructor, symbol))
                 {
                     var location = node.GetFirstToken().GetLocation();
                     var symbolUsageInfo = GetSymbolUsageInfo(node, semanticModel, syntaxFacts, semanticFacts, cancellationToken);
@@ -652,11 +623,12 @@ void CollectMatchingReferences(ISymbol originalUnreducedSymbolDefinition, Syntax
             }
         }
 
-        protected static bool Matches(ISymbol? symbol1, ISymbol notNulloriginalUnreducedSymbol2)
+        protected static bool Matches(ISymbol? symbol1, ISymbol notNullOriginalUnreducedSymbol2)
         {
+            Contract.ThrowIfFalse(notNullOriginalUnreducedSymbol2.GetOriginalUnreducedDefinition().Equals(notNullOriginalUnreducedSymbol2));
             return symbol1 != null && SymbolEquivalenceComparer.Instance.Equals(
                 symbol1.GetOriginalUnreducedDefinition(),
-                notNulloriginalUnreducedSymbol2);
+                notNullOriginalUnreducedSymbol2);
         }
 
         protected static SymbolUsageInfo GetSymbolUsageInfo(
@@ -907,13 +879,6 @@ protected abstract ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDoc
             TSymbol symbol, Document document, SemanticModel semanticModel,
             FindReferencesSearchOptions options, CancellationToken cancellationToken);
 
-        public override Task<ImmutableArray<Project>> DetermineProjectsToSearchAsync(ISymbol symbol, Solution solution, IImmutableSet<Project>? projects, CancellationToken cancellationToken)
-        {
-            return symbol is TSymbol typedSymbol && CanFind(typedSymbol)
-                ? DetermineProjectsToSearchAsync(typedSymbol, solution, projects, cancellationToken)
-                : SpecializedTasks.EmptyImmutableArray<Project>();
-        }
-
         public override Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
             ISymbol symbol, Project project, IImmutableSet<Document>? documents,
             FindReferencesSearchOptions options, CancellationToken cancellationToken)
@@ -948,13 +913,6 @@ symbol is TSymbol typedSymbol &&
             return SpecializedTasks.EmptyImmutableArray<(ISymbol symbol, FindReferencesCascadeDirection cascadeDirection)>();
         }
 
-        protected virtual Task<ImmutableArray<Project>> DetermineProjectsToSearchAsync(
-            TSymbol symbol, Solution solution, IImmutableSet<Project>? projects, CancellationToken cancellationToken)
-        {
-            return DependentProjectsFinder.GetDependentProjectsAsync(
-                solution, symbol, projects, cancellationToken);
-        }
-
         protected virtual Task<ImmutableArray<(ISymbol symbol, FindReferencesCascadeDirection cascadeDirection)>> DetermineCascadedSymbolsAsync(
             TSymbol symbol, Solution solution, IImmutableSet<Project>? projects,
             FindReferencesSearchOptions options, FindReferencesCascadeDirection cascadeDirection,
@@ -1026,10 +984,8 @@ protected static ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocum
             Func<SyntaxToken, SyntaxNode>? findParentNode,
             CancellationToken cancellationToken)
         {
-            var findInGlobalSuppressions = ShouldFindReferencesInGlobalSuppressions(symbol, out var docCommentId);
             var symbolsMatchAsync = GetStandardSymbolsMatchFunction(symbol, findParentNode, document.Project.Solution, cancellationToken);
-            return FindReferencesInDocumentAsync(document, semanticModel, tokensMatch,
-                symbolsMatchAsync, docCommentId, findInGlobalSuppressions, cancellationToken);
+            return FindReferencesInDocumentAsync(document, semanticModel, tokensMatch, symbolsMatchAsync, cancellationToken);
         }
 
         protected static async ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
@@ -1037,24 +993,13 @@ protected static async ValueTask<ImmutableArray<FinderLocation>> FindReferencesI
             SemanticModel semanticModel,
             Func<SyntaxToken, bool> tokensMatch,
             Func<SyntaxToken, SemanticModel, ValueTask<(bool matched, CandidateReason reason)>> symbolsMatchAsync,
-            string? docCommentId,
-            bool findInGlobalSuppressions,
             CancellationToken cancellationToken)
         {
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
             // Now that we have Doc Comments in place, We are searching for References in the Trivia as well by setting descendIntoTrivia: true
             var tokens = root.DescendantTokens(descendIntoTrivia: true);
-            var references = await FindReferencesInTokensAsync(document, semanticModel, tokens, tokensMatch, symbolsMatchAsync, cancellationToken).ConfigureAwait(false);
-
-            if (!findInGlobalSuppressions)
-                return references;
-
-            RoslynDebug.Assert(docCommentId != null);
-            var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
-            var referencesInGlobalSuppressions = await FindReferencesInDocumentInsideGlobalSuppressionsAsync(
-                document, semanticModel, syntaxFacts, docCommentId, cancellationToken).ConfigureAwait(false);
-            return references.AddRange(referencesInGlobalSuppressions);
+            return await FindReferencesInTokensAsync(document, semanticModel, tokens, tokensMatch, symbolsMatchAsync, cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder_GlobalSuppressions.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder_GlobalSuppressions.cs
index 5450352c9ed44..2c9d3ecb5c206 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder_GlobalSuppressions.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder_GlobalSuppressions.cs
@@ -17,7 +17,7 @@ namespace Microsoft.CodeAnalysis.FindSymbols.Finders
 {
     internal abstract partial class AbstractReferenceFinder : IReferenceFinder
     {
-        protected static bool ShouldFindReferencesInGlobalSuppressions(ISymbol symbol, [NotNullWhen(returnValue: true)] out string? documentationCommentId)
+        private static bool ShouldFindReferencesInGlobalSuppressions(ISymbol symbol, [NotNullWhen(returnValue: true)] out string? documentationCommentId)
         {
             if (!SupportsGlobalSuppression(symbol))
             {
@@ -54,29 +54,27 @@ static bool SupportsGlobalSuppression(ISymbol symbol)
         protected static async ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentInsideGlobalSuppressionsAsync(
             Document document,
             SemanticModel semanticModel,
-            ISyntaxFacts syntaxFacts,
-            string docCommentId,
+            ISymbol symbol,
             CancellationToken cancellationToken)
         {
+            if (!ShouldFindReferencesInGlobalSuppressions(symbol, out var docCommentId))
+                return ImmutableArray<FinderLocation>.Empty;
+
             // Check if we have any relevant global attributes in this document.
             var info = await SyntaxTreeIndex.GetRequiredIndexAsync(document, cancellationToken).ConfigureAwait(false);
             if (!info.ContainsGlobalAttributes)
-            {
                 return ImmutableArray<FinderLocation>.Empty;
-            }
 
             var suppressMessageAttribute = semanticModel.Compilation.SuppressMessageAttributeType();
             if (suppressMessageAttribute == null)
-            {
                 return ImmutableArray<FinderLocation>.Empty;
-            }
 
             // Check if we have any instances of the symbol documentation comment ID string literals within global attributes.
             // These string literals represent references to the symbol.
             if (!TryGetExpectedDocumentationCommentId(docCommentId, out var expectedDocCommentId))
-            {
                 return ImmutableArray<FinderLocation>.Empty;
-            }
+
+            var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
 
             // We map the positions of documentation ID literals in tree to string literal tokens,
             // perform semantic checks to ensure these are valid references to the symbol
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ConstructorSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ConstructorSymbolReferenceFinder.cs
index 07e8bafc0afb6..992adf5d97b37 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ConstructorSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ConstructorSymbolReferenceFinder.cs
@@ -38,20 +38,20 @@ protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSear
             CancellationToken cancellationToken)
         {
             var typeName = symbol.ContainingType.Name;
-            var documentsWithName = await FindDocumentsAsync(project, documents, findInGlobalSuppressions: true, cancellationToken, typeName).ConfigureAwait(false);
+
+            var documentsWithName = await FindDocumentsAsync(project, documents, cancellationToken, typeName).ConfigureAwait(false);
             var documentsWithType = await FindDocumentsAsync(project, documents, symbol.ContainingType.SpecialType.ToPredefinedType(), cancellationToken).ConfigureAwait(false);
+
             var documentsWithAttribute = TryGetNameWithoutAttributeSuffix(typeName, project.LanguageServices.GetRequiredService<ISyntaxFactsService>(), out var simpleName)
-                ? await FindDocumentsAsync(project, documents, findInGlobalSuppressions: false, cancellationToken, simpleName).ConfigureAwait(false)
-                : SpecializedCollections.EmptyEnumerable<Document>();
+                ? await FindDocumentsAsync(project, documents, cancellationToken, simpleName).ConfigureAwait(false)
+                : ImmutableArray<Document>.Empty;
 
             var documentsWithImplicitObjectCreations = symbol.MethodKind == MethodKind.Constructor
                 ? await FindDocumentsWithImplicitObjectCreationExpressionAsync(project, documents, cancellationToken).ConfigureAwait(false)
                 : ImmutableArray<Document>.Empty;
 
-            return documentsWithName.Concat(documentsWithType, documentsWithImplicitObjectCreations)
-                                    .Concat(documentsWithAttribute)
-                                    .Distinct()
-                                    .ToImmutableArray();
+            var documentsWithGlobalAttributes = await FindDocumentsWithGlobalAttributesAsync(project, documents, cancellationToken).ConfigureAwait(false);
+            return documentsWithName.Concat(documentsWithType, documentsWithImplicitObjectCreations, documentsWithAttribute, documentsWithGlobalAttributes);
         }
 
         private static bool IsPotentialReference(
@@ -84,10 +84,13 @@ internal async ValueTask<ImmutableArray<FinderLocation>> FindAllReferencesInDocu
 
             var normalReferences = await FindReferencesInDocumentWorkerAsync(methodSymbol, document, semanticModel, findParentNode, cancellationToken).ConfigureAwait(false);
             var nonAliasTypeReferences = await NamedTypeSymbolReferenceFinder.FindNonAliasReferencesAsync(methodSymbol.ContainingType, document, semanticModel, cancellationToken).ConfigureAwait(false);
+
             var aliasReferences = await FindAliasReferencesAsync(
                 nonAliasTypeReferences, methodSymbol, document, semanticModel,
                 findParentNode, cancellationToken).ConfigureAwait(false);
-            return normalReferences.Concat(aliasReferences);
+
+            var suppressionReferences = await FindReferencesInDocumentInsideGlobalSuppressionsAsync(document, semanticModel, methodSymbol, cancellationToken).ConfigureAwait(false);
+            return normalReferences.Concat(aliasReferences, suppressionReferences);
         }
 
         private async Task<ImmutableArray<FinderLocation>> FindReferencesInDocumentWorkerAsync(
@@ -170,9 +173,7 @@ static bool IsRelevantDocument(SyntaxTreeIndex syntaxTreeInfo)
                 => syntaxTreeInfo.ContainsImplicitObjectCreation;
 
             void CollectMatchingReferences(
-                ISymbol originalUnreducedSymbolDefinition, SyntaxNode node,
-                ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts,
-                ArrayBuilder<FinderLocation> locations)
+                SyntaxNode node, ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, ArrayBuilder<FinderLocation> locations)
             {
                 if (!syntaxFacts.IsImplicitObjectCreationExpression(node))
                     return;
@@ -187,7 +188,7 @@ void CollectMatchingReferences(
                     return;
 
                 var constructor = semanticModel.GetSymbolInfo(node, cancellationToken).Symbol;
-                if (Matches(constructor, originalUnreducedSymbolDefinition))
+                if (Matches(constructor, symbol))
                 {
                     var location = node.GetFirstToken().GetLocation();
                     var symbolUsageInfo = GetSymbolUsageInfo(node, semanticModel, syntaxFacts, semanticFacts, cancellationToken);
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/EventSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/EventSymbolReferenceFinder.cs
index 059f739c5c777..f9fb71287efab 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/EventSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/EventSymbolReferenceFinder.cs
@@ -37,14 +37,16 @@ protected override bool CanFind(IEventSymbol symbol)
                               .Concat(associatedNamedTypes.SelectAsArray(n => ((ISymbol)n, cascadeDirection)));
         }
 
-        protected override Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
+        protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
             IEventSymbol symbol,
             Project project,
             IImmutableSet<Document>? documents,
             FindReferencesSearchOptions options,
             CancellationToken cancellationToken)
         {
-            return FindDocumentsAsync(project, documents, findInGlobalSuppressions: true, cancellationToken, symbol.Name);
+            var documentsWithName = await FindDocumentsAsync(project, documents, cancellationToken, symbol.Name).ConfigureAwait(false);
+            var documentsWithGlobalAttributes = await FindDocumentsWithGlobalAttributesAsync(project, documents, cancellationToken).ConfigureAwait(false);
+            return documentsWithName.Concat(documentsWithGlobalAttributes);
         }
 
         protected override ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ExplicitConversionSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ExplicitConversionSymbolReferenceFinder.cs
index 31ab46d43bc63..ce6d27ca569d1 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ExplicitConversionSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ExplicitConversionSymbolReferenceFinder.cs
@@ -12,10 +12,10 @@
 
 namespace Microsoft.CodeAnalysis.FindSymbols.Finders
 {
-    internal partial class ExplicitConversionSymbolReferenceFinder : AbstractReferenceFinder<IMethodSymbol>
+    internal partial class ExplicitConversionSymbolReferenceFinder : AbstractMethodOrPropertyOrEventSymbolReferenceFinder<IMethodSymbol>
     {
         protected override bool CanFind(IMethodSymbol symbol)
-            => symbol is { MethodKind: MethodKind.Conversion, Name: WellKnownMemberNames.ExplicitConversionName } &&
+            => symbol is { MethodKind: MethodKind.Conversion, Name: WellKnownMemberNames.ExplicitConversionName or WellKnownMemberNames.ImplicitConversionName } &&
                GetUnderlyingNamedType(symbol.ReturnType) is not null;
 
         private static INamedTypeSymbol? GetUnderlyingNamedType(ITypeSymbol symbol)
@@ -40,7 +40,7 @@ protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSear
 
             var underlyingNamedType = GetUnderlyingNamedType(symbol.ReturnType);
             Contract.ThrowIfNull(underlyingNamedType);
-            var documentsWithName = await FindDocumentsAsync(project, documents, findInGlobalSuppressions: false, cancellationToken, underlyingNamedType.Name).ConfigureAwait(false);
+            var documentsWithName = await FindDocumentsAsync(project, documents, cancellationToken, underlyingNamedType.Name).ConfigureAwait(false);
             var documentsWithType = await FindDocumentsAsync(project, documents, underlyingNamedType.SpecialType.ToPredefinedType(), cancellationToken).ConfigureAwait(false);
 
             using var _ = ArrayBuilder<Document>.GetInstance(out var result);
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/FieldSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/FieldSymbolReferenceFinder.cs
index 829999659d2f6..ccc563fb70130 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/FieldSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/FieldSymbolReferenceFinder.cs
@@ -27,24 +27,28 @@ protected override bool CanFind(IFieldSymbol symbol)
                 : SpecializedTasks.EmptyImmutableArray<(ISymbol symbol, FindReferencesCascadeDirection cascadeDirection)>();
         }
 
-        protected override Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
+        protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
             IFieldSymbol symbol,
             Project project,
             IImmutableSet<Document>? documents,
             FindReferencesSearchOptions options,
             CancellationToken cancellationToken)
         {
-            return FindDocumentsAsync(project, documents, findInGlobalSuppressions: true, cancellationToken, symbol.Name);
+            var documentsWithName = await FindDocumentsAsync(project, documents, cancellationToken, symbol.Name).ConfigureAwait(false);
+            var documentsWithGlobalAttributes = await FindDocumentsWithGlobalAttributesAsync(project, documents, cancellationToken).ConfigureAwait(false);
+            return documentsWithName.Concat(documentsWithGlobalAttributes);
         }
 
-        protected override ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
+        protected override async ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
             IFieldSymbol symbol,
             Document document,
             SemanticModel semanticModel,
             FindReferencesSearchOptions options,
             CancellationToken cancellationToken)
         {
-            return FindReferencesInDocumentUsingSymbolNameAsync(symbol, document, semanticModel, cancellationToken);
+            var nameReferences = await FindReferencesInDocumentUsingSymbolNameAsync(symbol, document, semanticModel, cancellationToken).ConfigureAwait(false);
+            var suppressionReferences = await FindReferencesInDocumentInsideGlobalSuppressionsAsync(document, semanticModel, symbol, cancellationToken).ConfigureAwait(false);
+            return nameReferences.Concat(suppressionReferences);
         }
     }
 }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/IReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/IReferenceFinder.cs
index d6219a3c8f7ab..6284cab2e7785 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/IReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/IReferenceFinder.cs
@@ -29,22 +29,6 @@ internal interface IReferenceFinder
             FindReferencesSearchOptions options, FindReferencesCascadeDirection cascadeDirection,
             CancellationToken cancellationToken);
 
-        /// <summary>
-        /// Called by the find references search engine to determine which projects should be
-        /// searched for a given symbol.  The returned projects will then be searched in parallel. If
-        /// the implementation does not care about the provided symbol then null can be returned
-        /// from this method.
-        /// 
-        /// Implementations should endeavor to keep the list of returned projects as small as
-        /// possible to keep search time down to a minimum.  Returning the entire list of projects in
-        /// a solution is not recommended (unless, of course, there is reasonable reason to believe
-        /// there are references in every project).
-        /// 
-        /// Implementations of this method must be thread-safe.
-        /// </summary>
-        Task<ImmutableArray<Project>> DetermineProjectsToSearchAsync(
-            ISymbol symbol, Solution solution, IImmutableSet<Project>? projects, CancellationToken cancellationToken);
-
         /// <summary>
         /// Called by the find references search engine to determine which documents in the supplied
         /// project need to be searched for references.  Only projects returned by
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs
index a2b57b754e0ee..5a412595189c7 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs
@@ -61,7 +61,7 @@ protected override Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsyn
             // Also, we only look for files that have the name of the owning type.  This helps filter
             // down the set considerably.
             Contract.ThrowIfNull(symbol.DeclaringMethod);
-            return FindDocumentsAsync(project, documents, findInGlobalSuppressions: false, cancellationToken, symbol.Name,
+            return FindDocumentsAsync(project, documents, cancellationToken, symbol.Name,
                 GetMemberNameWithoutInterfaceName(symbol.DeclaringMethod.Name),
                 symbol.DeclaringMethod.ContainingType.Name);
         }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamedTypeSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamedTypeSymbolReferenceFinder.cs
index 7ff58d482f381..80aa784e30f5d 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamedTypeSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamedTypeSymbolReferenceFinder.cs
@@ -54,14 +54,15 @@ protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSear
         {
             var syntaxFacts = project.LanguageServices.GetRequiredService<ISyntaxFactsService>();
 
-            var documentsWithName = await FindDocumentsAsync(project, documents, findInGlobalSuppressions: true, cancellationToken, symbol.Name).ConfigureAwait(false);
+            var documentsWithName = await FindDocumentsAsync(project, documents, cancellationToken, symbol.Name).ConfigureAwait(false);
             var documentsWithType = await FindDocumentsAsync(project, documents, symbol.SpecialType.ToPredefinedType(), cancellationToken).ConfigureAwait(false);
+
             var documentsWithAttribute = TryGetNameWithoutAttributeSuffix(symbol.Name, syntaxFacts, out var simpleName)
-                ? await FindDocumentsAsync(project, documents, findInGlobalSuppressions: false, cancellationToken, simpleName).ConfigureAwait(false)
+                ? await FindDocumentsAsync(project, documents, cancellationToken, simpleName).ConfigureAwait(false)
                 : ImmutableArray<Document>.Empty;
 
-            return documentsWithName.Concat(documentsWithType)
-                                    .Concat(documentsWithAttribute);
+            var documentsWithGlobalAttributes = await FindDocumentsWithGlobalAttributesAsync(project, documents, cancellationToken).ConfigureAwait(false);
+            return documentsWithName.Concat(documentsWithType, documentsWithAttribute, documentsWithGlobalAttributes);
         }
 
         private static bool IsPotentialReference(
@@ -84,7 +85,8 @@ protected override async ValueTask<ImmutableArray<FinderLocation>> FindReference
             var nonAliasReferences = await FindNonAliasReferencesAsync(namedType, document, semanticModel, cancellationToken).ConfigureAwait(false);
             var symbolsMatch = GetStandardSymbolsMatchFunction(namedType, null, document.Project.Solution, cancellationToken);
             var aliasReferences = await FindAliasReferencesAsync(nonAliasReferences, document, semanticModel, symbolsMatch, cancellationToken).ConfigureAwait(false);
-            return nonAliasReferences.Concat(aliasReferences);
+            var suppressionReferences = await FindReferencesInDocumentInsideGlobalSuppressionsAsync(document, semanticModel, namedType, cancellationToken).ConfigureAwait(false);
+            return nonAliasReferences.Concat(aliasReferences, suppressionReferences);
         }
 
         internal static async ValueTask<ImmutableArray<FinderLocation>> FindNonAliasReferencesAsync(
@@ -132,8 +134,6 @@ private static ValueTask<ImmutableArray<FinderLocation>> FindPredefinedTypeRefer
             return FindReferencesInDocumentAsync(document, semanticModel, t =>
                 IsPotentialReference(predefinedType, syntaxFacts, t),
                 (t, m) => ValueTaskFactory.FromResult((matched: true, reason: CandidateReason.None)),
-                docCommentId: null,
-                findInGlobalSuppressions: false,
                 cancellationToken);
         }
 
@@ -146,8 +146,7 @@ private static ValueTask<ImmutableArray<FinderLocation>> FindAttributeReferences
             var symbolsMatch = GetStandardSymbolsMatchFunction(namedType, null, document.Project.Solution, cancellationToken);
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
             return TryGetNameWithoutAttributeSuffix(namedType.Name, syntaxFacts, out var simpleName)
-                ? FindReferencesInDocumentUsingIdentifierAsync(simpleName, document, semanticModel,
-                    symbolsMatch, docCommentId: null, findInGlobalSuppressions: false, cancellationToken)
+                ? FindReferencesInDocumentUsingIdentifierAsync(namedType, simpleName, document, semanticModel, symbolsMatch, cancellationToken)
                 : new ValueTask<ImmutableArray<FinderLocation>>(ImmutableArray<FinderLocation>.Empty);
         }
     }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamespaceSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamespaceSymbolReferenceFinder.cs
index d12c73a8fb677..f4c5df42ff47b 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamespaceSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamespaceSymbolReferenceFinder.cs
@@ -17,14 +17,16 @@ internal class NamespaceSymbolReferenceFinder : AbstractReferenceFinder<INamespa
         protected override bool CanFind(INamespaceSymbol symbol)
             => true;
 
-        protected override Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
+        protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
             INamespaceSymbol symbol,
             Project project,
             IImmutableSet<Document>? documents,
             FindReferencesSearchOptions options,
             CancellationToken cancellationToken)
         {
-            return FindDocumentsAsync(project, documents, findInGlobalSuppressions: true, cancellationToken, GetNamespaceIdentifierName(symbol));
+            var documentsWithName = await FindDocumentsAsync(project, documents, cancellationToken, GetNamespaceIdentifierName(symbol)).ConfigureAwait(false);
+            var documentsWithGlobalAttributes = await FindDocumentsWithGlobalAttributesAsync(project, documents, cancellationToken).ConfigureAwait(false);
+            return documentsWithGlobalAttributes.Concat(documentsWithName);
         }
 
         private static string GetNamespaceIdentifierName(INamespaceSymbol symbol)
@@ -55,12 +57,8 @@ protected override async ValueTask<ImmutableArray<FinderLocation>> FindReference
 
             var aliasReferences = await FindAliasReferencesAsync(nonAliasReferences, symbol, document, semanticModel, cancellationToken).ConfigureAwait(false);
 
-            var suppressionReferences = ShouldFindReferencesInGlobalSuppressions(symbol, out var docCommentId)
-                ? await FindReferencesInDocumentInsideGlobalSuppressionsAsync(document, semanticModel,
-                    syntaxFacts, docCommentId, cancellationToken).ConfigureAwait(false)
-                : ImmutableArray<FinderLocation>.Empty;
-
-            return nonAliasReferences.Concat(aliasReferences).Concat(suppressionReferences);
+            var suppressionReferences = await FindReferencesInDocumentInsideGlobalSuppressionsAsync(document, semanticModel, symbol, cancellationToken).ConfigureAwait(false);
+            return nonAliasReferences.Concat(aliasReferences, suppressionReferences);
         }
     }
 }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OperatorSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OperatorSymbolReferenceFinder.cs
index 86b07956abb0b..97b038df27d23 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OperatorSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OperatorSymbolReferenceFinder.cs
@@ -10,12 +10,12 @@
 
 namespace Microsoft.CodeAnalysis.FindSymbols.Finders
 {
-    internal class OperatorSymbolReferenceFinder : AbstractReferenceFinder<IMethodSymbol>
+    internal class OperatorSymbolReferenceFinder : AbstractMethodOrPropertyOrEventSymbolReferenceFinder<IMethodSymbol>
     {
         protected override bool CanFind(IMethodSymbol symbol)
             => symbol.MethodKind == MethodKind.UserDefinedOperator;
 
-        protected override Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
+        protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsync(
             IMethodSymbol symbol,
             Project project,
             IImmutableSet<Document>? documents,
@@ -23,10 +23,12 @@ protected override Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsyn
             CancellationToken cancellationToken)
         {
             var op = symbol.GetPredefinedOperator();
-            return FindDocumentsAsync(project, documents, op, cancellationToken);
+            var documentsWithOp = await FindDocumentsAsync(project, documents, op, cancellationToken).ConfigureAwait(false);
+            var documentsWithGlobalAttributes = await FindDocumentsWithGlobalAttributesAsync(project, documents, cancellationToken).ConfigureAwait(false);
+            return documentsWithOp.Concat(documentsWithGlobalAttributes);
         }
 
-        protected override ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
+        protected override async ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
             IMethodSymbol symbol,
             Document document,
             SemanticModel semanticModel,
@@ -36,9 +38,12 @@ protected override ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDoc
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
             var op = symbol.GetPredefinedOperator();
 
-            return FindReferencesInDocumentAsync(symbol, document, semanticModel, t =>
+            var opReferences = await FindReferencesInDocumentAsync(symbol, document, semanticModel, t =>
                 IsPotentialReference(syntaxFacts, op, t),
-                cancellationToken);
+                cancellationToken).ConfigureAwait(false);
+            var suppressionReferences = await FindReferencesInDocumentInsideGlobalSuppressionsAsync(document, semanticModel, symbol, cancellationToken).ConfigureAwait(false);
+
+            return opReferences.Concat(suppressionReferences);
         }
 
         private static bool IsPotentialReference(
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OrdinaryMethodReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OrdinaryMethodReferenceFinder.cs
index c147242d317eb..277c7e024977d 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OrdinaryMethodReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OrdinaryMethodReferenceFinder.cs
@@ -84,7 +84,7 @@ protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSear
             // searches for these, then we should find usages of 'lock(goo)' or 'synclock(goo)'
             // since they implicitly call those methods.
 
-            var ordinaryDocuments = await FindDocumentsAsync(project, documents, findInGlobalSuppressions: true, cancellationToken, methodSymbol.Name).ConfigureAwait(false);
+            var ordinaryDocuments = await FindDocumentsAsync(project, documents, cancellationToken, methodSymbol.Name).ConfigureAwait(false);
             var forEachDocuments = IsForEachMethod(methodSymbol)
                 ? await FindDocumentsWithForEachStatementsAsync(project, documents, cancellationToken).ConfigureAwait(false)
                 : ImmutableArray<Document>.Empty;
@@ -97,7 +97,8 @@ protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSear
                 ? await FindDocumentsWithAwaitExpressionAsync(project, documents, cancellationToken).ConfigureAwait(false)
                 : ImmutableArray<Document>.Empty;
 
-            return ordinaryDocuments.Concat(forEachDocuments).Concat(deconstructDocuments).Concat(awaitExpressionDocuments);
+            var documentsWithGlobalAttributes = await FindDocumentsWithGlobalAttributesAsync(project, documents, cancellationToken).ConfigureAwait(false);
+            return ordinaryDocuments.Concat(forEachDocuments, deconstructDocuments, awaitExpressionDocuments, documentsWithGlobalAttributes);
         }
 
         private static bool IsForEachMethod(IMethodSymbol methodSymbol)
@@ -120,31 +121,22 @@ protected override async ValueTask<ImmutableArray<FinderLocation>> FindReference
             FindReferencesSearchOptions options,
             CancellationToken cancellationToken)
         {
-            var nameMatches = await FindReferencesInDocumentUsingSymbolNameAsync(
-                symbol,
-                document,
-                semanticModel,
-                cancellationToken).ConfigureAwait(false);
+            var nameMatches = await FindReferencesInDocumentUsingSymbolNameAsync(symbol, document, semanticModel, cancellationToken).ConfigureAwait(false);
 
-            if (IsForEachMethod(symbol))
-            {
-                var forEachMatches = await FindReferencesInForEachStatementsAsync(symbol, document, semanticModel, cancellationToken).ConfigureAwait(false);
-                nameMatches = nameMatches.Concat(forEachMatches);
-            }
+            var forEachMatches = IsForEachMethod(symbol)
+                ? await FindReferencesInForEachStatementsAsync(symbol, document, semanticModel, cancellationToken).ConfigureAwait(false)
+                : ImmutableArray<FinderLocation>.Empty;
 
-            if (IsDeconstructMethod(symbol))
-            {
-                var deconstructMatches = await FindReferencesInDeconstructionAsync(symbol, document, semanticModel, cancellationToken).ConfigureAwait(false);
-                nameMatches = nameMatches.Concat(deconstructMatches);
-            }
+            var deconstructMatches = IsDeconstructMethod(symbol)
+                ? await FindReferencesInDeconstructionAsync(symbol, document, semanticModel, cancellationToken).ConfigureAwait(false)
+                : ImmutableArray<FinderLocation>.Empty;
 
-            if (IsGetAwaiterMethod(symbol))
-            {
-                var getAwaiterMatches = await FindReferencesInAwaitExpressionAsync(symbol, document, semanticModel, cancellationToken).ConfigureAwait(false);
-                nameMatches = nameMatches.Concat(getAwaiterMatches);
-            }
+            var getAwaiterMatches = IsGetAwaiterMethod(symbol)
+                ? await FindReferencesInAwaitExpressionAsync(symbol, document, semanticModel, cancellationToken).ConfigureAwait(false)
+                : ImmutableArray<FinderLocation>.Empty;
 
-            return nameMatches;
+            var suppressionReferences = await FindReferencesInDocumentInsideGlobalSuppressionsAsync(document, semanticModel, symbol, cancellationToken).ConfigureAwait(false);
+            return nameMatches.Concat(forEachMatches, deconstructMatches, getAwaiterMatches, suppressionReferences);
         }
     }
 }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ParameterSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ParameterSymbolReferenceFinder.cs
index 68d79f6ce6aea..2c3b49348348c 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ParameterSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ParameterSymbolReferenceFinder.cs
@@ -31,7 +31,7 @@ protected override Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsyn
             // elsewhere as "paramName:" or "paramName:=".  We can narrow the search by
             // filtering down to matches of that form.  For now we just return any document
             // that references something with this name.
-            return FindDocumentsAsync(project, documents, findInGlobalSuppressions: false, cancellationToken, symbol.Name);
+            return FindDocumentsAsync(project, documents, cancellationToken, symbol.Name);
         }
 
         protected override ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertyAccessorSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertyAccessorSymbolReferenceFinder.cs
index f138a610f5a93..7c6cf9cdc3a13 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertyAccessorSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertyAccessorSymbolReferenceFinder.cs
@@ -41,24 +41,23 @@ protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSear
             // First, find any documents with the full name of the accessor (i.e. get_Goo).
             // This will find explicit calls to the method (which can happen when C# references
             // a VB parameterized property).
-            var result = await FindDocumentsAsync(
-                project, documents, findInGlobalSuppressions: true, cancellationToken, symbol.Name).ConfigureAwait(false);
+            var documentsWithName = await FindDocumentsAsync(project, documents, cancellationToken, symbol.Name).ConfigureAwait(false);
 
+            var propertyDocuments = ImmutableArray<Document>.Empty;
             if (symbol.AssociatedSymbol is IPropertySymbol property &&
                 options.AssociatePropertyReferencesWithSpecificAccessor)
             {
                 // we want to associate normal property references with the specific accessor being
                 // referenced.  So we also need to include documents with our property's name. Just
                 // defer to the Property finder to find these docs and combine them with the result.
-                var propertyDocuments = await ReferenceFinders.Property.DetermineDocumentsToSearchAsync(
+                propertyDocuments = await ReferenceFinders.Property.DetermineDocumentsToSearchAsync(
                     property, project, documents,
                     options.With(associatePropertyReferencesWithSpecificAccessor: false),
                     cancellationToken).ConfigureAwait(false);
-
-                result = result.AddRange(propertyDocuments);
             }
 
-            return result;
+            var documentsWithGlobalAttributes = await FindDocumentsWithGlobalAttributesAsync(project, documents, cancellationToken).ConfigureAwait(false);
+            return documentsWithName.Concat(propertyDocuments, documentsWithGlobalAttributes);
         }
 
         protected override async ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertySymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertySymbolReferenceFinder.cs
index f91b23d9ebc7c..63f3f140c535a 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertySymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertySymbolReferenceFinder.cs
@@ -57,7 +57,7 @@ protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSear
             FindReferencesSearchOptions options,
             CancellationToken cancellationToken)
         {
-            var ordinaryDocuments = await FindDocumentsAsync(project, documents, findInGlobalSuppressions: true, cancellationToken, symbol.Name).ConfigureAwait(false);
+            var ordinaryDocuments = await FindDocumentsAsync(project, documents, cancellationToken, symbol.Name).ConfigureAwait(false);
 
             var forEachDocuments = IsForEachProperty(symbol)
                 ? await FindDocumentsWithForEachStatementsAsync(project, documents, cancellationToken).ConfigureAwait(false)
@@ -71,9 +71,8 @@ protected override async Task<ImmutableArray<Document>> DetermineDocumentsToSear
                 ? await FindDocumentWithIndexerMemberCrefAsync(project, documents, cancellationToken).ConfigureAwait(false)
                 : ImmutableArray<Document>.Empty;
 
-            return ordinaryDocuments.Concat(forEachDocuments)
-                                    .Concat(elementAccessDocument)
-                                    .Concat(indexerMemberCrefDocument);
+            var documentsWithGlobalAttributes = await FindDocumentsWithGlobalAttributesAsync(project, documents, cancellationToken).ConfigureAwait(false);
+            return ordinaryDocuments.Concat(forEachDocuments, elementAccessDocument, indexerMemberCrefDocument, documentsWithGlobalAttributes);
         }
 
         private static bool IsForEachProperty(IPropertySymbol symbol)
@@ -110,8 +109,8 @@ protected override async ValueTask<ImmutableArray<FinderLocation>> FindReference
                 ? await FindIndexerReferencesAsync(symbol, document, semanticModel, options, cancellationToken).ConfigureAwait(false)
                 : ImmutableArray<FinderLocation>.Empty;
 
-            return nameReferences.Concat(forEachReferences)
-                                 .Concat(indexerReferences);
+            var suppressionReferences = await FindReferencesInDocumentInsideGlobalSuppressionsAsync(document, semanticModel, symbol, cancellationToken).ConfigureAwait(false);
+            return nameReferences.Concat(forEachReferences, indexerReferences, suppressionReferences);
         }
 
         private static Task<ImmutableArray<Document>> FindDocumentWithElementAccessExpressionsAsync(
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/TypeParameterSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/TypeParameterSymbolReferenceFinder.cs
index 124111318696f..56835c1bd83c1 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/TypeParameterSymbolReferenceFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/TypeParameterSymbolReferenceFinder.cs
@@ -27,7 +27,7 @@ protected override Task<ImmutableArray<Document>> DetermineDocumentsToSearchAsyn
             // parameter has a different name in different parts that we won't find it.  However,
             // this only happens in error situations.  It is not legal in C# to use a different
             // name for a type parameter in different parts.
-            return FindDocumentsAsync(project, documents, findInGlobalSuppressions: false, cancellationToken, symbol.Name, symbol.ContainingType.Name);
+            return FindDocumentsAsync(project, documents, cancellationToken, symbol.Name, symbol.ContainingType.Name);
         }
 
         protected override ValueTask<ImmutableArray<FinderLocation>> FindReferencesInDocumentAsync(
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolFinder_Hierarchy.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolFinder_Hierarchy.cs
index c61be915c53c7..e9e2640818a1e 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolFinder_Hierarchy.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolFinder_Hierarchy.cs
@@ -94,7 +94,7 @@ internal static async Task<ImmutableArray<ISymbol>> FindImplementedInterfaceMemb
             ISymbol symbol, Solution solution, IImmutableSet<Project> projects = null, CancellationToken cancellationToken = default)
         {
             // Member can only implement interface members if it is an explicit member, or if it is
-            // public and non static.
+            // public
             if (symbol != null)
             {
                 var explicitImplementations = symbol.ExplicitInterfaceImplementations();
@@ -103,7 +103,7 @@ internal static async Task<ImmutableArray<ISymbol>> FindImplementedInterfaceMemb
                     return explicitImplementations;
                 }
                 else if (
-                    symbol.DeclaredAccessibility == Accessibility.Public && !symbol.IsStatic &&
+                    symbol.DeclaredAccessibility == Accessibility.Public &&
                     (symbol.ContainingType.TypeKind == TypeKind.Class || symbol.ContainingType.TypeKind == TypeKind.Struct))
                 {
                     // Interface implementation is a tricky thing.  A method may implement an interface
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
index 42a85afd2a9b9..cf51a8dd5b372 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
@@ -81,7 +81,7 @@ private static async Task<Checksum> ComputeSourceSymbolsChecksumAsync(ProjectSta
 
             // Order the documents by FilePath.  Default ordering in the RemoteWorkspace is
             // to be ordered by Guid (which is not consistent across VS sessions).
-            var textChecksumsTasks = projectState.DocumentStates.States.OrderBy(state => state.FilePath, StringComparer.Ordinal).Select(async state =>
+            var textChecksumsTasks = projectState.DocumentStates.States.Values.OrderBy(state => state.FilePath, StringComparer.Ordinal).Select(async state =>
             {
                 var documentStateChecksum = await state.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false);
                 return documentStateChecksum.Text;
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex.cs b/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex.cs
index 82ab256777262..f85592f1418da 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex.cs
@@ -45,6 +45,9 @@ private SyntaxTreeIndex(
 
         public static async Task PrecalculateAsync(Document document, CancellationToken cancellationToken)
         {
+            if (!document.SupportsSyntaxTree)
+                return;
+
             using (Logger.LogBlock(FunctionId.SyntaxTreeIndex_Precalculate, cancellationToken))
             {
                 Debug.Assert(document.IsFromPrimaryBranch());
@@ -82,6 +85,9 @@ public static async ValueTask<SyntaxTreeIndex> GetRequiredIndexAsync(Document do
             bool loadOnly,
             CancellationToken cancellationToken)
         {
+            if (!document.SupportsSyntaxTree)
+                return null;
+
             // See if we already cached an index with this direct document index.  If so we can just
             // return it with no additional work.
             if (!s_documentToIndex.TryGetValue(document, out var index))
@@ -108,6 +114,9 @@ public static async ValueTask<SyntaxTreeIndex> GetRequiredIndexAsync(Document do
             bool loadOnly,
             CancellationToken cancellationToken)
         {
+            if (!document.SupportsSyntaxTree)
+                return null;
+
             var checksum = await GetChecksumAsync(document, cancellationToken).ConfigureAwait(false);
 
             // Check if we have an index for a previous version of this document.  If our
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs b/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs
index 023c1b101b74a..21b777e411ecd 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -11,7 +9,6 @@
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -25,15 +22,7 @@ internal interface IDeclaredSymbolInfoFactoryService : ILanguageService
     {
         // `rootNamespace` is required for VB projects that has non-global namespace as root namespace,
         // otherwise we would not be able to get correct data from syntax.
-        bool TryGetDeclaredSymbolInfo(StringTable stringTable, SyntaxNode node, string rootNamespace, out DeclaredSymbolInfo declaredSymbolInfo);
-
-        // Get the name of the receiver type of specified extension method declaration node.
-        // The returned value would be "" or "[]" for complex types.
-        string GetReceiverTypeName(SyntaxNode node);
-
-        bool TryGetAliasesFromUsingDirective(SyntaxNode node, out ImmutableArray<(string aliasName, string name)> aliases);
-
-        string GetRootNamespace(CompilationOptions compilationOptions);
+        void AddDeclaredSymbolInfos(Document document, SyntaxNode root, ArrayBuilder<DeclaredSymbolInfo> declaredSymbolInfos, Dictionary<string, ArrayBuilder<int>> extensionMethodInfo, CancellationToken cancellationToken);
     }
 
     internal sealed partial class SyntaxTreeIndex
@@ -53,18 +42,23 @@ internal sealed partial class SyntaxTreeIndex
         /// this string table.  The table will have already served its purpose at that point and 
         /// doesn't need to be kept around further.
         /// </summary>
-        private static readonly ConditionalWeakTable<Project, StringTable> s_projectStringTable =
-            new();
+        private static readonly ConditionalWeakTable<Project, StringTable> s_projectStringTable = new();
 
         private static async Task<SyntaxTreeIndex> CreateIndexAsync(
             Document document, Checksum checksum, CancellationToken cancellationToken)
         {
-            var project = document.Project;
-            var stringTable = GetStringTable(project);
+            Contract.ThrowIfFalse(document.SupportsSyntaxTree);
+
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            return CreateIndex(document, root, checksum, cancellationToken);
+        }
 
-            var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
-            var infoFactory = document.GetLanguageService<IDeclaredSymbolInfoFactoryService>();
-            var ignoreCase = syntaxFacts != null && !syntaxFacts.IsCaseSensitive;
+        private static SyntaxTreeIndex CreateIndex(
+            Document document, SyntaxNode root, Checksum checksum, CancellationToken cancellationToken)
+        {
+            var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
+            var infoFactory = document.GetRequiredLanguageService<IDeclaredSymbolInfoFactoryService>();
+            var ignoreCase = !syntaxFacts.IsCaseSensitive;
             var isCaseSensitive = !ignoreCase;
 
             GetIdentifierSet(ignoreCase, out var identifiers, out var escapedIdentifiers);
@@ -72,9 +66,8 @@ private static async Task<SyntaxTreeIndex> CreateIndexAsync(
             var stringLiterals = StringLiteralHashSetPool.Allocate();
             var longLiterals = LongLiteralHashSetPool.Allocate();
 
-            var declaredSymbolInfos = ArrayBuilder<DeclaredSymbolInfo>.GetInstance();
-            var extensionMethodInfoBuilder = PooledDictionary<string, ArrayBuilder<int>>.GetInstance();
-            using var _ = PooledDictionary<string, string>.GetInstance(out var usingAliases);
+            using var _1 = ArrayBuilder<DeclaredSymbolInfo>.GetInstance(out var declaredSymbolInfos);
+            using var _2 = PooledDictionary<string, ArrayBuilder<int>>.GetInstance(out var extensionMethodInfo);
 
             try
             {
@@ -98,14 +91,11 @@ private static async Task<SyntaxTreeIndex> CreateIndexAsync(
 
                 if (syntaxFacts != null)
                 {
-                    var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                    var rootNamespace = infoFactory.GetRootNamespace(project.CompilationOptions);
-
                     foreach (var current in root.DescendantNodesAndTokensAndSelf(descendIntoTrivia: true))
                     {
                         if (current.IsNode)
                         {
-                            var node = (SyntaxNode)current;
+                            var node = current.AsNode();
 
                             containsForEachStatement = containsForEachStatement || syntaxFacts.IsForEachStatement(node);
                             containsLockStatement = containsLockStatement || syntaxFacts.IsLockStatement(node);
@@ -123,69 +113,6 @@ private static async Task<SyntaxTreeIndex> CreateIndexAsync(
                             containsImplicitObjectCreation = containsImplicitObjectCreation || syntaxFacts.IsImplicitObjectCreationExpression(node);
                             containsGlobalAttributes = containsGlobalAttributes || syntaxFacts.IsGlobalAttribute(node);
                             containsConversion = containsConversion || syntaxFacts.IsConversionExpression(node);
-
-                            if (syntaxFacts.IsUsingAliasDirective(node) && infoFactory.TryGetAliasesFromUsingDirective(node, out var aliases))
-                            {
-                                foreach (var (aliasName, name) in aliases)
-                                {
-                                    // In C#, it's valid to declare two alias with identical name,
-                                    // as long as they are in different containers.
-                                    //
-                                    // e.g.
-                                    //      using X = System.String;
-                                    //      namespace N
-                                    //      {
-                                    //          using X = System.Int32;
-                                    //      }
-                                    //
-                                    // If we detect this, we will simply treat extension methods whose
-                                    // target type is this alias as complex method.
-                                    if (usingAliases.ContainsKey(aliasName))
-                                    {
-                                        usingAliases[aliasName] = null;
-                                    }
-                                    else
-                                    {
-                                        usingAliases[aliasName] = name;
-                                    }
-                                }
-                            }
-
-                            // We've received a number of error reports where DeclaredSymbolInfo.GetSymbolAsync() will
-                            // crash because the document's syntax root doesn't contain the span of the node returned
-                            // by TryGetDeclaredSymbolInfo().  There are two possibilities for this crash:
-                            //   1) syntaxFacts.TryGetDeclaredSymbolInfo() is returning a bad span, or
-                            //   2) Document.GetSyntaxRootAsync() (called from DeclaredSymbolInfo.GetSymbolAsync) is
-                            //      returning a bad syntax root that doesn't represent the original parsed document.
-                            // By adding the `root.FullSpan.Contains()` check below, if we get similar crash reports in
-                            // the future then we know the problem lies in (2).  If, however, the problem is really in
-                            // TryGetDeclaredSymbolInfo, then this will at least prevent us from returning bad spans
-                            // and will prevent the crash from occurring.
-                            if (infoFactory.TryGetDeclaredSymbolInfo(stringTable, node, rootNamespace, out var declaredSymbolInfo))
-                            {
-                                if (root.FullSpan.Contains(declaredSymbolInfo.Span))
-                                {
-                                    var declaredSymbolInfoIndex = declaredSymbolInfos.Count;
-                                    declaredSymbolInfos.Add(declaredSymbolInfo);
-
-                                    AddExtensionMethodInfo(
-                                        infoFactory,
-                                        node,
-                                        usingAliases,
-                                        declaredSymbolInfoIndex,
-                                        declaredSymbolInfo,
-                                        extensionMethodInfoBuilder);
-                                }
-                                else
-                                {
-                                    var message =
-$@"Invalid span in {nameof(declaredSymbolInfo)}.
-{nameof(declaredSymbolInfo.Span)} = {declaredSymbolInfo.Span}
-{nameof(root.FullSpan)} = {root.FullSpan}";
-
-                                    FatalError.ReportAndCatch(new InvalidOperationException(message));
-                                }
-                            }
                         }
                         else
                         {
@@ -223,7 +150,7 @@ private static async Task<SyntaxTreeIndex> CreateIndexAsync(
 
                             if (syntaxFacts.IsCharacterLiteral(token))
                             {
-                                longLiterals.Add((char)token.Value);
+                                longLiterals.Add((char)token.Value!);
                             }
 
                             if (syntaxFacts.IsNumericLiteral(token))
@@ -247,6 +174,9 @@ private static async Task<SyntaxTreeIndex> CreateIndexAsync(
                             }
                         }
                     }
+
+                    infoFactory.AddDeclaredSymbolInfos(
+                        document, root, declaredSymbolInfos, extensionMethodInfo, cancellationToken);
                 }
 
                 return new SyntaxTreeIndex(
@@ -273,10 +203,9 @@ private static async Task<SyntaxTreeIndex> CreateIndexAsync(
                             containsImplicitObjectCreation,
                             containsGlobalAttributes,
                             containsConversion),
-                    new DeclarationInfo(
-                            declaredSymbolInfos.ToImmutable()),
+                    new DeclarationInfo(declaredSymbolInfos.ToImmutable()),
                     new ExtensionMethodInfo(
-                        extensionMethodInfoBuilder.ToImmutableDictionary(
+                        extensionMethodInfo.ToImmutableDictionary(
                             static kvp => kvp.Key,
                             static kvp => kvp.Value.ToImmutable())));
             }
@@ -286,58 +215,13 @@ private static async Task<SyntaxTreeIndex> CreateIndexAsync(
                 StringLiteralHashSetPool.ClearAndFree(stringLiterals);
                 LongLiteralHashSetPool.ClearAndFree(longLiterals);
 
-                foreach (var (_, builder) in extensionMethodInfoBuilder)
-                {
+                foreach (var (_, builder) in extensionMethodInfo)
                     builder.Free();
-                }
-
-                extensionMethodInfoBuilder.Free();
-                declaredSymbolInfos.Free();
             }
         }
 
-        private static void AddExtensionMethodInfo(
-            IDeclaredSymbolInfoFactoryService infoFactory,
-            SyntaxNode node,
-            PooledDictionary<string, string> aliases,
-            int declaredSymbolInfoIndex,
-            DeclaredSymbolInfo declaredSymbolInfo,
-            PooledDictionary<string, ArrayBuilder<int>> extensionMethodsInfoBuilder)
-        {
-            if (declaredSymbolInfo.Kind != DeclaredSymbolInfoKind.ExtensionMethod)
-            {
-                return;
-            }
-
-            var receiverTypeName = infoFactory.GetReceiverTypeName(node);
-
-            // Target type is an alias
-            if (aliases.TryGetValue(receiverTypeName, out var originalName))
-            {
-                // it is an alias of multiple with identical name,
-                // simply treat it as a complex method.
-                if (originalName == null)
-                {
-                    receiverTypeName = Extensions.ComplexReceiverTypeName;
-                }
-                else
-                {
-                    // replace the alias with its original name.
-                    receiverTypeName = originalName;
-                }
-            }
-
-            if (!extensionMethodsInfoBuilder.TryGetValue(receiverTypeName, out var arrayBuilder))
-            {
-                arrayBuilder = ArrayBuilder<int>.GetInstance();
-                extensionMethodsInfoBuilder[receiverTypeName] = arrayBuilder;
-            }
-
-            arrayBuilder.Add(declaredSymbolInfoIndex);
-        }
-
-        private static StringTable GetStringTable(Project project)
-            => s_projectStringTable.GetValue(project, _ => StringTable.GetInstance());
+        public static StringTable GetStringTable(Project project)
+            => s_projectStringTable.GetValue(project, static _ => StringTable.GetInstance());
 
         private static void GetIdentifierSet(bool ignoreCase, out HashSet<string> identifiers, out HashSet<string> escapedIdentifiers)
         {
diff --git a/src/Workspaces/Core/Portable/LanguageServices/DeclaredSymbolFactoryService/AbstractDeclaredSymbolInfoFactoryService.cs b/src/Workspaces/Core/Portable/LanguageServices/DeclaredSymbolFactoryService/AbstractDeclaredSymbolInfoFactoryService.cs
index 32c29a86e044a..c5621b0ccc46f 100644
--- a/src/Workspaces/Core/Portable/LanguageServices/DeclaredSymbolFactoryService/AbstractDeclaredSymbolInfoFactoryService.cs
+++ b/src/Workspaces/Core/Portable/LanguageServices/DeclaredSymbolFactoryService/AbstractDeclaredSymbolInfoFactoryService.cs
@@ -8,18 +8,31 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Globalization;
+using System.Runtime.CompilerServices;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.LanguageServices
 {
-    internal abstract class AbstractDeclaredSymbolInfoFactoryService : IDeclaredSymbolInfoFactoryService
+    internal abstract class AbstractDeclaredSymbolInfoFactoryService<
+        TCompilationUnitSyntax,
+        TUsingDirectiveSyntax,
+        TNamespaceDeclarationSyntax,
+        TTypeDeclarationSyntax,
+        TEnumDeclarationSyntax,
+        TMemberDeclarationSyntax> : IDeclaredSymbolInfoFactoryService
+        where TCompilationUnitSyntax : SyntaxNode
+        where TUsingDirectiveSyntax : SyntaxNode
+        where TNamespaceDeclarationSyntax : TMemberDeclarationSyntax
+        where TTypeDeclarationSyntax : TMemberDeclarationSyntax
+        where TEnumDeclarationSyntax : TMemberDeclarationSyntax
+        where TMemberDeclarationSyntax : SyntaxNode
     {
-        private const string GenericTypeNameManglingString = "`";
-        private static readonly string[] s_aritySuffixesOneToNine = { "`1", "`2", "`3", "`4", "`5", "`6", "`7", "`8", "`9" };
-
         private static readonly ObjectPool<List<Dictionary<string, string>>> s_aliasMapListPool
             = SharedPools.Default<List<Dictionary<string, string>>>();
 
@@ -31,6 +44,33 @@ private static readonly ObjectPool<List<Dictionary<string, string>>> s_aliasMapL
         private static readonly ObjectPool<Dictionary<string, string>> s_aliasMapPool
             = SharedPools.StringIgnoreCaseDictionary<string>();
 
+        protected AbstractDeclaredSymbolInfoFactoryService()
+        {
+        }
+
+        protected abstract SyntaxList<TMemberDeclarationSyntax> GetChildren(TCompilationUnitSyntax node);
+        protected abstract SyntaxList<TMemberDeclarationSyntax> GetChildren(TNamespaceDeclarationSyntax node);
+        protected abstract SyntaxList<TMemberDeclarationSyntax> GetChildren(TTypeDeclarationSyntax node);
+        protected abstract IEnumerable<TMemberDeclarationSyntax> GetChildren(TEnumDeclarationSyntax node);
+
+        protected abstract SyntaxList<TUsingDirectiveSyntax> GetUsingAliases(TCompilationUnitSyntax node);
+        protected abstract SyntaxList<TUsingDirectiveSyntax> GetUsingAliases(TNamespaceDeclarationSyntax node);
+
+        protected abstract string GetContainerDisplayName(TMemberDeclarationSyntax namespaceDeclaration);
+        protected abstract string GetFullyQualifiedContainerName(TMemberDeclarationSyntax memberDeclaration, string rootNamespace);
+
+        protected abstract void AddDeclaredSymbolInfosWorker(
+            SyntaxNode container, TMemberDeclarationSyntax memberDeclaration, StringTable stringTable, ArrayBuilder<DeclaredSymbolInfo> declaredSymbolInfos, Dictionary<string, string> aliases, Dictionary<string, ArrayBuilder<int>> extensionMethodInfo, string containerDisplayName, string fullyQualifiedContainerName, CancellationToken cancellationToken);
+        /// <summary>
+        /// Get the name of the target type of specified extension method declaration. 
+        /// The node provided must be an extension method declaration,  i.e. calling `TryGetDeclaredSymbolInfo()` 
+        /// on `node` should return a `DeclaredSymbolInfo` of kind `ExtensionMethod`. 
+        /// If the return value is null, then it means this is a "complex" method (as described at <see cref="SyntaxTreeIndex.ExtensionMethodInfo"/>).
+        /// </summary>
+        protected abstract string GetReceiverTypeName(TMemberDeclarationSyntax node);
+        protected abstract bool TryGetAliasesFromUsingDirective(TUsingDirectiveSyntax node, out ImmutableArray<(string aliasName, string name)> aliases);
+        protected abstract string GetRootNamespace(CompilationOptions compilationOptions);
+
         protected static List<Dictionary<string, string>> AllocateAliasMapList()
             => s_aliasMapListPool.Allocate();
 
@@ -60,7 +100,7 @@ protected static string CreateValueTupleTypeString(int elementCount)
                 return ValueTupleName;
             }
             // A ValueTuple can have up to 8 type parameters.
-            return ValueTupleName + GetMetadataAritySuffix(elementCount > 8 ? 8 : elementCount);
+            return ValueTupleName + ArityUtilities.GetMetadataAritySuffix(elementCount > 8 ? 8 : elementCount);
         }
 
         protected static void FreeAliasMapList(List<Dictionary<string, string>> list)
@@ -110,26 +150,154 @@ protected static void Intern(StringTable stringTable, ArrayBuilder<string> build
             }
         }
 
-        public static string GetMetadataAritySuffix(int arity)
+        public void AddDeclaredSymbolInfos(
+            Document document,
+            SyntaxNode root,
+            ArrayBuilder<DeclaredSymbolInfo> declaredSymbolInfos,
+            Dictionary<string, ArrayBuilder<int>> extensionMethodInfo,
+            CancellationToken cancellationToken)
         {
-            Debug.Assert(arity > 0);
-            return (arity <= s_aritySuffixesOneToNine.Length)
-                ? s_aritySuffixesOneToNine[arity - 1]
-                : string.Concat(GenericTypeNameManglingString, arity.ToString(CultureInfo.InvariantCulture));
+            var project = document.Project;
+            var stringTable = SyntaxTreeIndex.GetStringTable(project);
+            var rootNamespace = this.GetRootNamespace(project.CompilationOptions);
+
+            using var _1 = PooledDictionary<string, string>.GetInstance(out var aliases);
+
+            foreach (var usingAlias in GetUsingAliases((TCompilationUnitSyntax)root))
+            {
+                if (this.TryGetAliasesFromUsingDirective(usingAlias, out var current))
+                    AddAliases(aliases, current);
+            }
+
+            foreach (var child in GetChildren((TCompilationUnitSyntax)root))
+                AddDeclaredSymbolInfos(root, child, stringTable, rootNamespace, declaredSymbolInfos, aliases, extensionMethodInfo, "", "", cancellationToken);
         }
 
-        public abstract bool TryGetDeclaredSymbolInfo(StringTable stringTable, SyntaxNode node, string rootNamespace, out DeclaredSymbolInfo declaredSymbolInfo);
+        private void AddDeclaredSymbolInfos(
+            SyntaxNode container,
+            TMemberDeclarationSyntax memberDeclaration,
+            StringTable stringTable,
+            string rootNamespace,
+            ArrayBuilder<DeclaredSymbolInfo> declaredSymbolInfos,
+            Dictionary<string, string> aliases,
+            Dictionary<string, ArrayBuilder<int>> extensionMethodInfo,
+            string containerDisplayName,
+            string fullyQualifiedContainerName,
+            CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
 
-        /// <summary>
-        /// Get the name of the target type of specified extension method declaration. 
-        /// The node provided must be an extension method declaration,  i.e. calling `TryGetDeclaredSymbolInfo()` 
-        /// on `node` should return a `DeclaredSymbolInfo` of kind `ExtensionMethod`. 
-        /// If the return value is null, then it means this is a "complex" method (as described at <see cref="SyntaxTreeIndex.ExtensionMethodInfo"/>).
-        /// </summary>
-        public abstract string GetReceiverTypeName(SyntaxNode node);
+            if (memberDeclaration is TNamespaceDeclarationSyntax namespaceDeclaration)
+            {
+                var innerContainerDisplayName = GetContainerDisplayName(memberDeclaration);
+                var innerFullyQualifiedContainerName = GetFullyQualifiedContainerName(memberDeclaration, rootNamespace);
 
-        public abstract bool TryGetAliasesFromUsingDirective(SyntaxNode node, out ImmutableArray<(string aliasName, string name)> aliases);
+                foreach (var usingAlias in GetUsingAliases(namespaceDeclaration))
+                {
+                    if (this.TryGetAliasesFromUsingDirective(usingAlias, out var current))
+                        AddAliases(aliases, current);
+                }
 
-        public abstract string GetRootNamespace(CompilationOptions compilationOptions);
+                foreach (var child in GetChildren(namespaceDeclaration))
+                {
+                    AddDeclaredSymbolInfos(
+                        memberDeclaration, child, stringTable, rootNamespace, declaredSymbolInfos, aliases, extensionMethodInfo,
+                        innerContainerDisplayName, innerFullyQualifiedContainerName, cancellationToken);
+                }
+            }
+            else if (memberDeclaration is TTypeDeclarationSyntax baseTypeDeclaration)
+            {
+                var innerContainerDisplayName = GetContainerDisplayName(memberDeclaration);
+                var innerFullyQualifiedContainerName = GetFullyQualifiedContainerName(memberDeclaration, rootNamespace);
+                foreach (var child in GetChildren(baseTypeDeclaration))
+                {
+                    AddDeclaredSymbolInfos(
+                        memberDeclaration, child, stringTable, rootNamespace, declaredSymbolInfos, aliases, extensionMethodInfo,
+                        innerContainerDisplayName, innerFullyQualifiedContainerName, cancellationToken);
+                }
+            }
+            else if (memberDeclaration is TEnumDeclarationSyntax enumDeclaration)
+            {
+                var innerContainerDisplayName = GetContainerDisplayName(memberDeclaration);
+                var innerFullyQualifiedContainerName = GetFullyQualifiedContainerName(memberDeclaration, rootNamespace);
+                foreach (var child in GetChildren(enumDeclaration))
+                {
+                    AddDeclaredSymbolInfos(
+                        memberDeclaration, child, stringTable, rootNamespace, declaredSymbolInfos, aliases, extensionMethodInfo,
+                        innerContainerDisplayName, innerFullyQualifiedContainerName, cancellationToken);
+                }
+            }
+
+            AddDeclaredSymbolInfosWorker(
+                container,
+                memberDeclaration,
+                stringTable,
+                declaredSymbolInfos,
+                aliases,
+                extensionMethodInfo,
+                containerDisplayName,
+                fullyQualifiedContainerName,
+                cancellationToken);
+        }
+
+        protected void AddExtensionMethodInfo(
+            TMemberDeclarationSyntax node,
+            Dictionary<string, string> aliases,
+            int declaredSymbolInfoIndex,
+            Dictionary<string, ArrayBuilder<int>> extensionMethodsInfoBuilder)
+        {
+            var receiverTypeName = this.GetReceiverTypeName(node);
+
+            // Target type is an alias
+            if (aliases.TryGetValue(receiverTypeName, out var originalName))
+            {
+                // it is an alias of multiple with identical name,
+                // simply treat it as a complex method.
+                if (originalName == null)
+                {
+                    receiverTypeName = FindSymbols.Extensions.ComplexReceiverTypeName;
+                }
+                else
+                {
+                    // replace the alias with its original name.
+                    receiverTypeName = originalName;
+                }
+            }
+
+            if (!extensionMethodsInfoBuilder.TryGetValue(receiverTypeName, out var arrayBuilder))
+            {
+                arrayBuilder = ArrayBuilder<int>.GetInstance();
+                extensionMethodsInfoBuilder[receiverTypeName] = arrayBuilder;
+            }
+
+            arrayBuilder.Add(declaredSymbolInfoIndex);
+        }
+
+        private static void AddAliases(Dictionary<string, string> allAliases, ImmutableArray<(string aliasName, string name)> aliases)
+        {
+            foreach (var (aliasName, name) in aliases)
+            {
+                // In C#, it's valid to declare two alias with identical name,
+                // as long as they are in different containers.
+                //
+                // e.g.
+                //      using X = System.String;
+                //      namespace N
+                //      {
+                //          using X = System.Int32;
+                //      }
+                //
+                // If we detect this, we will simply treat extension methods whose
+                // target type is this alias as complex method.
+                if (allAliases.ContainsKey(aliasName))
+                {
+                    allAliases[aliasName] = null;
+                }
+                else
+                {
+                    allAliases[aliasName] = name;
+                }
+            }
+        }
     }
 }
diff --git a/src/Workspaces/Core/Portable/LanguageServices/DeclaredSymbolFactoryService/ArityUtilities.cs b/src/Workspaces/Core/Portable/LanguageServices/DeclaredSymbolFactoryService/ArityUtilities.cs
new file mode 100644
index 0000000000000..6270ef9aed9b4
--- /dev/null
+++ b/src/Workspaces/Core/Portable/LanguageServices/DeclaredSymbolFactoryService/ArityUtilities.cs
@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Diagnostics;
+using System.Globalization;
+
+namespace Microsoft.CodeAnalysis.LanguageServices
+{
+    internal static class ArityUtilities
+    {
+        private const string GenericTypeNameManglingString = "`";
+        private static readonly string[] s_aritySuffixesOneToNine = { "`1", "`2", "`3", "`4", "`5", "`6", "`7", "`8", "`9" };
+
+        public static string GetMetadataAritySuffix(int arity)
+        {
+            Debug.Assert(arity > 0);
+            return (arity <= s_aritySuffixesOneToNine.Length)
+                ? s_aritySuffixesOneToNine[arity - 1]
+                : string.Concat(GenericTypeNameManglingString, arity.ToString(CultureInfo.InvariantCulture));
+        }
+    }
+}
diff --git a/src/Workspaces/Core/Portable/Microsoft.CodeAnalysis.Workspaces.csproj b/src/Workspaces/Core/Portable/Microsoft.CodeAnalysis.Workspaces.csproj
index ce4e50284c83b..606559a0d60f3 100644
--- a/src/Workspaces/Core/Portable/Microsoft.CodeAnalysis.Workspaces.csproj
+++ b/src/Workspaces/Core/Portable/Microsoft.CodeAnalysis.Workspaces.csproj
@@ -8,7 +8,7 @@
     <TargetFrameworks>netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <DefineConstants>$(DefineConstants);WORKSPACE</DefineConstants>
     <GeneratePerformanceSensitiveAttribute>true</GeneratePerformanceSensitiveAttribute>
-    <ApplyNgenOptimization>partial</ApplyNgenOptimization>
+    <ApplyNgenOptimization Condition="'$(TargetFramework)' == 'netstandard2.0'">partial</ApplyNgenOptimization>
 
     <!-- NuGet -->
     <IsPackable>true</IsPackable>
@@ -48,6 +48,7 @@
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.UnitTesting" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Features" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager.UnitTests" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.Orchestrator" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.Orchestrator.UnitTests" Partner="UnitTesting" Key="$(UnitTestingKey)" />
@@ -59,6 +60,7 @@
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Remote.ServiceHub" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Remote.Workspaces" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery.UnitTests" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.VisualBasic.EditorFeatures" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.VisualBasic.Features" />
diff --git a/src/Workspaces/Core/Portable/Recommendations/AbstractRecommendationServiceRunner.cs b/src/Workspaces/Core/Portable/Recommendations/AbstractRecommendationServiceRunner.cs
index c984ef25b7ff3..25a09dad3771e 100644
--- a/src/Workspaces/Core/Portable/Recommendations/AbstractRecommendationServiceRunner.cs
+++ b/src/Workspaces/Core/Portable/Recommendations/AbstractRecommendationServiceRunner.cs
@@ -44,11 +44,11 @@ public AbstractRecommendationServiceRunner(
         // This code is to help give intellisense in the following case: 
         // query.Include(a => a.SomeProperty).ThenInclude(a => a.
         // where there are more than one overloads of ThenInclude accepting different types of parameters.
-        private ImmutableArray<ISymbol> GetMemberSymbolsForParameter(IParameterSymbol parameter, int position, bool useBaseReferenceAccessibility)
+        private ImmutableArray<ISymbol> GetMemberSymbolsForParameter(IParameterSymbol parameter, int position, bool useBaseReferenceAccessibility, bool unwrapNullable)
         {
             var symbols = TryGetMemberSymbolsForLambdaParameter(parameter, position);
             return symbols.IsDefault
-                ? GetMemberSymbols(parameter.Type, position, excludeInstance: false, useBaseReferenceAccessibility)
+                ? GetMemberSymbols(parameter.Type, position, excludeInstance: false, useBaseReferenceAccessibility, unwrapNullable)
                 : symbols;
         }
 
@@ -110,7 +110,7 @@ private ImmutableArray<ISymbol> TryGetMemberSymbolsForLambdaParameter(IParameter
             // parameter the compiler inferred as it may have made a completely suitable inference for it.
             return parameterTypeSymbols
                 .Concat(parameter.Type)
-                .SelectMany(parameterTypeSymbol => GetMemberSymbols(parameterTypeSymbol, position, excludeInstance: false, useBaseReferenceAccessibility: false))
+                .SelectMany(parameterTypeSymbol => GetMemberSymbols(parameterTypeSymbol, position, excludeInstance: false, useBaseReferenceAccessibility: false, unwrapNullable: false))
                 .ToImmutableArray();
         }
 
@@ -299,16 +299,22 @@ protected ImmutableArray<ISymbol> GetMemberSymbols(
             ISymbol container,
             int position,
             bool excludeInstance,
-            bool useBaseReferenceAccessibility)
+            bool useBaseReferenceAccessibility,
+            bool unwrapNullable)
         {
             // For a normal parameter, we have a specialized codepath we use to ensure we properly get lambda parameter
             // information that the compiler may fail to give.
             if (container is IParameterSymbol parameter)
-                return GetMemberSymbolsForParameter(parameter, position, useBaseReferenceAccessibility);
+                return GetMemberSymbolsForParameter(parameter, position, useBaseReferenceAccessibility, unwrapNullable);
 
             if (container is not INamespaceOrTypeSymbol namespaceOrType)
                 return ImmutableArray<ISymbol>.Empty;
 
+            if (unwrapNullable && namespaceOrType is ITypeSymbol typeSymbol)
+            {
+                namespaceOrType = typeSymbol.RemoveNullableIfPresent();
+            }
+
             return useBaseReferenceAccessibility
                 ? _context.SemanticModel.LookupBaseMembers(position)
                 : LookupSymbolsInContainer(namespaceOrType, position, excludeInstance);
diff --git a/src/Workspaces/Core/Portable/Rename/ConflictEngine/ConflictResolver.Session.cs b/src/Workspaces/Core/Portable/Rename/ConflictEngine/ConflictResolver.Session.cs
index a3ba3ff2515df..e90a954880bbd 100644
--- a/src/Workspaces/Core/Portable/Rename/ConflictEngine/ConflictResolver.Session.cs
+++ b/src/Workspaces/Core/Portable/Rename/ConflictEngine/ConflictResolver.Session.cs
@@ -724,9 +724,10 @@ private async Task AddDocumentsWithPotentialConflictsAsync(IEnumerable<Document>
                     foreach (var document in documents)
                     {
                         if (_documentsIdsToBeCheckedForConflict.Contains(document.Id))
-                        {
                             continue;
-                        }
+
+                        if (!document.SupportsSyntaxTree)
+                            continue;
 
                         var info = await SyntaxTreeIndex.GetRequiredIndexAsync(document, _cancellationToken).ConfigureAwait(false);
                         if (info.ProbablyContainsEscapedIdentifier(_originalText))
diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/ISymbolExtensions.cs b/src/Workspaces/Core/Portable/Shared/Extensions/ISymbolExtensions.cs
index 85ea4c5dc0d83..8928d65495161 100644
--- a/src/Workspaces/Core/Portable/Shared/Extensions/ISymbolExtensions.cs
+++ b/src/Workspaces/Core/Portable/Shared/Extensions/ISymbolExtensions.cs
@@ -15,6 +15,7 @@
 using System.Xml.Linq;
 using System.Xml.XPath;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
@@ -269,7 +270,7 @@ private static DocumentationComment GetDocumentationComment(ISymbol symbol, Hash
                     element.ReplaceNodes(RewriteMany(symbol, visitedSymbols, compilation, element.Nodes().ToArray(), cancellationToken));
                     xmlText = element.ToString(SaveOptions.DisableFormatting);
                 }
-                catch
+                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
                 {
                 }
             }
@@ -424,28 +425,46 @@ private static XNode[] RewriteMany(ISymbol symbol, HashSet<ISymbol>? visitedSymb
                     }
                 }
 
-                var loadedElements = TrySelectNodes(document, xpathValue);
-                if (loadedElements is null)
-                {
-                    return Array.Empty<XNode>();
-                }
+                // Consider the following code, we want Test<int>.Clone to say "Clones a Test<int>" instead of "Clones a int", thus
+                // we rewrite `typeparamref`s as cref pointing to the correct type:
+                /*
+                    public class Test<T> : ICloneable<Test<T>>
+                    {
+                        /// <inheritdoc/>
+                        public Test<T> Clone() => new();
+                    }
 
-                if (loadedElements?.Length > 0)
+                    /// <summary>A type that has clonable instances.</summary>
+                    /// <typeparam name="T">The type of instances that can be cloned.</typeparam>
+                    public interface ICloneable<T>
+                    {
+                        /// <summary>Clones a <typeparamref name="T"/>.</summary>
+                        public T Clone();
+                    }
+                */
+                // Note: there is no way to cref an instantiated generic type. See https://github.com/dotnet/csharplang/issues/401
+                var typeParameterRefs = document.Descendants(DocumentationCommentXmlNames.TypeParameterReferenceElementName).ToImmutableArray();
+                foreach (var typeParameterRef in typeParameterRefs)
                 {
-                    // change the current XML file path for nodes contained in the document:
-                    // prototype(inheritdoc): what should the file path be?
-                    var result = RewriteMany(symbol, visitedSymbols, compilation, loadedElements, cancellationToken);
-
-                    // The elements could be rewritten away if they are includes that refer to invalid
-                    // (but existing and accessible) XML files.  If this occurs, behave as if we
-                    // had failed to find any XPath results (as in Dev11).
-                    if (result.Length > 0)
+                    if (typeParameterRef.Attribute(DocumentationCommentXmlNames.NameAttributeName) is var typeParamName)
                     {
-                        return result;
+                        var index = symbol.OriginalDefinition.GetAllTypeParameters().IndexOf(p => p.Name == typeParamName.Value);
+                        if (index >= 0)
+                        {
+                            var typeArgs = symbol.GetAllTypeArguments();
+                            if (index < typeArgs.Length)
+                            {
+                                var docId = typeArgs[index].GetDocumentationCommentId();
+                                var replacement = new XElement(DocumentationCommentXmlNames.SeeElementName);
+                                replacement.SetAttributeValue(DocumentationCommentXmlNames.CrefAttributeName, docId);
+                                typeParameterRef.ReplaceWith(replacement);
+                            }
+                        }
                     }
                 }
 
-                return null;
+                var loadedElements = TrySelectNodes(document, xpathValue);
+                return loadedElements ?? Array.Empty<XNode>();
             }
             catch (XmlException)
             {
@@ -487,7 +506,8 @@ private static XNode[] RewriteMany(ISymbol symbol, HashSet<ISymbol>? visitedSymb
                 {
                     if (typeSymbol.TypeKind == TypeKind.Class)
                     {
-                        // prototype(inheritdoc): when does base class take precedence over interface?
+                        // Classes use the base type as the default inheritance candidate. A different target (e.g. an
+                        // interface) can be provided via the 'path' attribute.
                         return typeSymbol.BaseType;
                     }
                     else if (typeSymbol.TypeKind == TypeKind.Interface)
diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.cs b/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.cs
index 49c76de2e08fb..cd195f4789a1e 100644
--- a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.cs
+++ b/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.cs
@@ -170,7 +170,6 @@ where SymbolEquivalenceComparer.Instance.Equals(explicitInterfaceMethod, constru
                 from baseType in typeSymbol.GetBaseTypesAndThis()
                 from member in baseType.GetMembers(constructedInterfaceMember.Name).OfType<TSymbol>()
                 where member.DeclaredAccessibility == Accessibility.Public &&
-                      !member.IsStatic &&
                       SignatureComparer.Instance.HaveSameSignatureAndConstraintsAndReturnTypeAndAccessors(member, constructedInterfaceMember, syntaxFacts.IsCaseSensitive)
                 select member;
 
diff --git a/src/Workspaces/Core/Portable/Shared/TestHooks/AsynchronousOperationListenerProvider+NullOperationListener.cs b/src/Workspaces/Core/Portable/Shared/TestHooks/AsynchronousOperationListenerProvider+NullOperationListener.cs
index 416aac4067946..823fdd4131ffa 100644
--- a/src/Workspaces/Core/Portable/Shared/TestHooks/AsynchronousOperationListenerProvider+NullOperationListener.cs
+++ b/src/Workspaces/Core/Portable/Shared/TestHooks/AsynchronousOperationListenerProvider+NullOperationListener.cs
@@ -6,6 +6,7 @@
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Shared.TestHooks
 {
@@ -19,10 +20,44 @@ public IAsyncToken BeginAsyncOperation(
                 [CallerFilePath] string filePath = "",
                 [CallerLineNumber] int lineNumber = 0) => EmptyAsyncToken.Instance;
 
-            public async Task<bool> Delay(TimeSpan delay, CancellationToken cancellationToken)
+            public Task<bool> Delay(TimeSpan delay, CancellationToken cancellationToken)
             {
-                await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
-                return true;
+                // This could be as simple as:
+                //     await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
+                //     return true;
+                // However, whereas in general cancellation is expected to be rare and thus throwing
+                // an exception in response isn't very impactful, here it's expected to be the case
+                // more often than not as the operation is being used to delay an operation because
+                // it's expected something else is going to happen to obviate the need for that
+                // operation.  Thus, we can spend a little more code avoiding the additional throw
+                // for the common case of an exception occurring.
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return Task.FromCanceled<bool>(cancellationToken);
+                }
+
+                var t = Task.Delay(delay, cancellationToken);
+                if (t.IsCompleted)
+                {
+                    // Avoid ContinueWith overheads for a 0 delay or if race conditions resulted
+                    // in the delay task being complete by the time we checked.
+                    return t.Status == TaskStatus.RanToCompletion
+                        ? SpecializedTasks.True
+                        : Task.FromCanceled<bool>(cancellationToken);
+                }
+
+                return t.ContinueWith(
+                    _ => true,
+                    CancellationToken.None,
+                    TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.NotOnCanceled,
+                    TaskScheduler.Default);
+
+                // Note the above passes CancellationToken.None and TaskContinuationOptions.NotOnCanceled.
+                // That's cheaper than passing cancellationToken and with the same semantics except
+                // that if the returned task does end up being canceled, any operation canceled exception
+                // thrown won't contain the cancellationToken.  If that ends up being impactful, it can
+                // be switched to use `cancellationToken, TaskContinuationOptions.ExecuteSynchronously`.
             }
         }
     }
diff --git a/src/Workspaces/Core/Portable/Shared/TestHooks/FeatureAttribute.cs b/src/Workspaces/Core/Portable/Shared/TestHooks/FeatureAttribute.cs
index 759e1e45b6a54..c1d410a65b6b0 100644
--- a/src/Workspaces/Core/Portable/Shared/TestHooks/FeatureAttribute.cs
+++ b/src/Workspaces/Core/Portable/Shared/TestHooks/FeatureAttribute.cs
@@ -13,6 +13,7 @@ internal static class FeatureAttribute
         public const string Classification = nameof(Classification);
         public const string CodeModel = nameof(CodeModel);
         public const string CompletionSet = nameof(CompletionSet);
+        public const string DesignerAttributes = nameof(DesignerAttributes);
         public const string DiagnosticService = nameof(DiagnosticService);
         public const string EncapsulateField = nameof(EncapsulateField);
         public const string ErrorList = nameof(ErrorList);
@@ -33,6 +34,7 @@ internal static class FeatureAttribute
         public const string NavigationBar = nameof(NavigationBar);
         public const string Outlining = nameof(Outlining);
         public const string PackageInstaller = nameof(PackageInstaller);
+        public const string PersistentStorage = nameof(PersistentStorage);
         public const string ReferenceHighlighting = nameof(ReferenceHighlighting);
         public const string Rename = nameof(Rename);
         public const string RenameTracking = nameof(RenameTracking);
@@ -42,6 +44,7 @@ internal static class FeatureAttribute
         public const string SignatureHelp = nameof(SignatureHelp);
         public const string Snippets = nameof(Snippets);
         public const string SolutionCrawler = nameof(SolutionCrawler);
+        public const string Telemetry = nameof(Telemetry);
         public const string TodoCommentList = nameof(TodoCommentList);
         public const string LanguageServer = nameof(LanguageServer);
         public const string Workspace = nameof(Workspace);
diff --git a/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingDelay.cs b/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingDelay.cs
deleted file mode 100644
index ccdd3f39c2a26..0000000000000
--- a/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingDelay.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Shared.TestHooks;
-using Roslyn.Utilities;
-
-namespace Roslyn.Utilities
-{
-    internal sealed class AsyncBatchingDelay
-    {
-        private readonly AsyncBatchingWorkQueue<bool> _workQueue;
-        private readonly Func<CancellationToken, Task> _processAsync;
-
-        public AsyncBatchingDelay(
-            TimeSpan delay,
-            Func<CancellationToken, Task> processAsync,
-            IAsynchronousOperationListener? asyncListener,
-            CancellationToken cancellationToken)
-        {
-            _processAsync = processAsync;
-
-            // We use an AsyncBatchingWorkQueue with a boolean, and just always add the
-            // same value at all times.
-            _workQueue = new AsyncBatchingWorkQueue<bool>(
-                delay,
-                OnNotifyAsync,
-                equalityComparer: EqualityComparer<bool>.Default,
-                asyncListener,
-                cancellationToken);
-        }
-
-        private Task OnNotifyAsync(ImmutableArray<bool> _, CancellationToken cancellationToken)
-        {
-            return _processAsync(cancellationToken);
-        }
-
-        public void RequeueWork()
-        {
-            // Value doesn't matter here as long as we're consistent.
-            _workQueue.AddWork(item: false);
-        }
-    }
-}
diff --git a/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue`0.cs b/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue`0.cs
new file mode 100644
index 0000000000000..a5ecc1df789f5
--- /dev/null
+++ b/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue`0.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+
+namespace Roslyn.Utilities
+{
+    /// <inheritdoc cref="AsyncBatchingWorkQueue{TItem, TResult}"/>
+    internal class AsyncBatchingWorkQueue : AsyncBatchingWorkQueue<VoidResult>
+    {
+        public AsyncBatchingWorkQueue(
+            TimeSpan delay,
+            Func<CancellationToken, ValueTask> processBatchAsync,
+            IAsynchronousOperationListener asyncListener,
+            CancellationToken cancellationToken)
+            : base(delay, Convert(processBatchAsync), EqualityComparer<VoidResult>.Default, asyncListener, cancellationToken)
+        {
+        }
+
+        private static Func<ImmutableArray<VoidResult>, CancellationToken, ValueTask> Convert(Func<CancellationToken, ValueTask> processBatchAsync)
+            => (items, ct) => processBatchAsync(ct);
+
+        public void AddWork()
+            => base.AddWork(default(VoidResult));
+    }
+}
diff --git a/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue`1.cs b/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue`1.cs
new file mode 100644
index 0000000000000..5e17e3090a256
--- /dev/null
+++ b/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue`1.cs
@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+
+namespace Roslyn.Utilities
+{
+    /// <inheritdoc cref="AsyncBatchingWorkQueue{TItem, TResult}"/>
+    internal class AsyncBatchingWorkQueue<TItem> : AsyncBatchingWorkQueue<TItem, VoidResult>
+    {
+        public AsyncBatchingWorkQueue(
+            TimeSpan delay,
+            Func<ImmutableArray<TItem>, CancellationToken, ValueTask> processBatchAsync,
+            IAsynchronousOperationListener asyncListener,
+            CancellationToken cancellationToken)
+            : this(delay,
+                   processBatchAsync,
+                   equalityComparer: null,
+                   asyncListener,
+                   cancellationToken)
+        {
+        }
+
+        public AsyncBatchingWorkQueue(
+            TimeSpan delay,
+            Func<ImmutableArray<TItem>, CancellationToken, ValueTask> processBatchAsync,
+            IEqualityComparer<TItem>? equalityComparer,
+            IAsynchronousOperationListener asyncListener,
+            CancellationToken cancellationToken)
+            : base(delay, Convert(processBatchAsync), equalityComparer, asyncListener, cancellationToken)
+        {
+        }
+
+        private static Func<ImmutableArray<TItem>, CancellationToken, ValueTask<VoidResult>> Convert(Func<ImmutableArray<TItem>, CancellationToken, ValueTask> processBatchAsync)
+            => async (items, ct) =>
+            {
+                await processBatchAsync(items, ct).ConfigureAwait(false);
+                return default;
+            };
+
+        public new Task WaitUntilCurrentBatchCompletesAsync()
+            => base.WaitUntilCurrentBatchCompletesAsync();
+    }
+}
diff --git a/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue.cs b/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue`2.cs
similarity index 67%
rename from src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue.cs
rename to src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue`2.cs
index 0d92a1461e5fa..debca352c369c 100644
--- a/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue.cs
+++ b/src/Workspaces/Core/Portable/Shared/Utilities/AsyncBatchingWorkQueue`2.cs
@@ -19,7 +19,7 @@ namespace Roslyn.Utilities
     /// along to be worked on.  Rounds of processing happen serially, only starting up after a
     /// previous round has completed.
     /// </summary>
-    internal class AsyncBatchingWorkQueue<TItem>
+    internal class AsyncBatchingWorkQueue<TItem, TResult>
     {
         /// <summary>
         /// Delay we wait after finishing the processing of one batch and starting up on then.
@@ -34,8 +34,8 @@ internal class AsyncBatchingWorkQueue<TItem>
         /// <summary>
         /// Callback to actually perform the processing of the next batch of work.
         /// </summary>
-        private readonly Func<ImmutableArray<TItem>, CancellationToken, Task> _processBatchAsync;
-        private readonly IAsynchronousOperationListener? _asyncListener;
+        private readonly Func<ImmutableArray<TItem>, CancellationToken, ValueTask<TResult>> _processBatchAsync;
+        private readonly IAsynchronousOperationListener _asyncListener;
         private readonly CancellationToken _cancellationToken;
 
         #region protected by lock
@@ -63,7 +63,7 @@ internal class AsyncBatchingWorkQueue<TItem>
         /// Task kicked off to do the next batch of processing of <see cref="_nextBatch"/>. These
         /// tasks form a chain so that the next task only processes when the previous one completes.
         /// </summary>
-        private Task _updateTask = Task.CompletedTask;
+        private Task<TResult?> _updateTask = Task.FromResult(default(TResult));
 
         /// <summary>
         /// Whether or not there is an existing task in flight that will process the current batch
@@ -76,23 +76,9 @@ internal class AsyncBatchingWorkQueue<TItem>
 
         public AsyncBatchingWorkQueue(
             TimeSpan delay,
-            Func<ImmutableArray<TItem>, CancellationToken, Task> processBatchAsync,
-            CancellationToken cancellationToken)
-            : this(delay,
-                   processBatchAsync,
-                   equalityComparer: null,
-                   asyncListener: null,
-                   cancellationToken)
-        {
-        }
-
-        /// <param name="processBatchAsync">Callback to add the new items to the current batch.  It is legal to mutate
-        /// the current batch (for example, clearing the batch or deduplicating)</param>
-        public AsyncBatchingWorkQueue(
-            TimeSpan delay,
-            Func<ImmutableArray<TItem>, CancellationToken, Task> processBatchAsync,
+            Func<ImmutableArray<TItem>, CancellationToken, ValueTask<TResult>> processBatchAsync,
             IEqualityComparer<TItem>? equalityComparer,
-            IAsynchronousOperationListener? asyncListener,
+            IAsynchronousOperationListener asyncListener,
             CancellationToken cancellationToken)
         {
             _delay = delay;
@@ -122,11 +108,35 @@ public void AddWork(IEnumerable<TItem> items)
             {
                 // add our work to the set we'll process in the next batch.
                 AddItemsToBatch(items);
-                TryKickOffNextBatchTask();
+
+                if (!_taskInFlight)
+                {
+                    // No in-flight task.  Kick one off to process these messages a second from now.
+                    // We always attach the task to the previous one so that notifications to the ui
+                    // follow the same order as the notification the OOP server sent to us.
+                    _updateTask = ContinueAfterDelay(_updateTask);
+                    _taskInFlight = true;
+                }
+            }
+
+            return;
+
+            async Task<TResult?> ContinueAfterDelay(Task lastTask)
+            {
+                using var _ = _asyncListener.BeginAsyncOperation(nameof(AddWork));
+                await lastTask.ConfigureAwait(false);
+
+                // Ensure that we always yield the current thread this is necessary for correctness as we are called
+                // inside a lock that _taskInFlight to true.  We must ensure that the work to process the next batch
+                // must be on another thread that runs afterwards, can only grab the thread once we release it and will
+                // then reset that bool back to false
+                await Task.Yield().ConfigureAwait(false);
+                await _asyncListener.Delay(_delay, _cancellationToken).ConfigureAwait(false);
+                return await ProcessNextBatchAsync(_cancellationToken).ConfigureAwait(false);
             }
         }
 
-        public Task WaitUntilCurrentBatchCompletesAsync()
+        public Task<TResult?> WaitUntilCurrentBatchCompletesAsync()
         {
             lock (_gate)
                 return _updateTask;
@@ -149,42 +159,7 @@ private void AddItemsToBatch(IEnumerable<TItem> items)
             }
         }
 
-        private void TryKickOffNextBatchTask()
-        {
-            Debug.Assert(Monitor.IsEntered(_gate));
-
-            if (!_taskInFlight)
-            {
-                // No in-flight task.  Kick one off to process these messages a second from now.
-                // We always attach the task to the previous one so that notifications to the ui
-                // follow the same order as the notification the OOP server sent to us.
-                if (_asyncListener is object)
-                {
-                    var token = _asyncListener.BeginAsyncOperation(nameof(TryKickOffNextBatchTask));
-
-                    _updateTask = _updateTask.ContinueWithAfterDelayFromAsync(
-                        _ => ProcessNextBatchAsync(_cancellationToken),
-                        _cancellationToken,
-                        (int)_delay.TotalMilliseconds,
-                        _asyncListener,
-                        TaskContinuationOptions.RunContinuationsAsynchronously,
-                        TaskScheduler.Default).CompletesAsyncOperation(token);
-                }
-                else
-                {
-                    _updateTask = _updateTask.ContinueWithAfterDelayFromAsync(
-                        _ => ProcessNextBatchAsync(_cancellationToken),
-                        _cancellationToken,
-                        (int)_delay.TotalMilliseconds,
-                        TaskContinuationOptions.RunContinuationsAsynchronously,
-                        TaskScheduler.Default);
-                }
-
-                _taskInFlight = true;
-            }
-        }
-
-        private Task ProcessNextBatchAsync(CancellationToken cancellationToken)
+        private ValueTask<TResult> ProcessNextBatchAsync(CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
             return _processBatchAsync(GetNextBatchAndResetQueue(), _cancellationToken);
diff --git a/src/Workspaces/Core/Portable/SolutionCrawler/IncrementalAnalyzerProviderMetadata.cs b/src/Workspaces/Core/Portable/SolutionCrawler/IncrementalAnalyzerProviderMetadata.cs
index f6a8f05de4c65..af4b6cc9ba553 100644
--- a/src/Workspaces/Core/Portable/SolutionCrawler/IncrementalAnalyzerProviderMetadata.cs
+++ b/src/Workspaces/Core/Portable/SolutionCrawler/IncrementalAnalyzerProviderMetadata.cs
@@ -15,15 +15,15 @@ internal class IncrementalAnalyzerProviderMetadata : WorkspaceKindMetadata
         public bool HighPriorityForActiveFile { get; }
         public string Name { get; }
 
-        public IncrementalAnalyzerProviderMetadata(IDictionary<string, object> data) :
-            base(data)
+        public IncrementalAnalyzerProviderMetadata(IDictionary<string, object> data)
+            : base(data)
         {
             this.HighPriorityForActiveFile = (bool)data.GetValueOrDefault("HighPriorityForActiveFile");
             this.Name = (string)data.GetValueOrDefault("Name");
         }
 
-        public IncrementalAnalyzerProviderMetadata(string name, bool highPriorityForActiveFile, params string[] workspaceKinds) :
-            base(workspaceKinds)
+        public IncrementalAnalyzerProviderMetadata(string name, bool highPriorityForActiveFile, params string[] workspaceKinds)
+            : base(workspaceKinds)
         {
             this.HighPriorityForActiveFile = highPriorityForActiveFile;
             this.Name = name;
diff --git a/src/Workspaces/Core/Portable/Storage/DesktopPersistenceStorageServiceFactory.cs b/src/Workspaces/Core/Portable/Storage/DesktopPersistenceStorageServiceFactory.cs
index 4408ca3467b3c..b912912731405 100644
--- a/src/Workspaces/Core/Portable/Storage/DesktopPersistenceStorageServiceFactory.cs
+++ b/src/Workspaces/Core/Portable/Storage/DesktopPersistenceStorageServiceFactory.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 
 // When building for source-build, there is no sqlite dependency
 #if !DOTNET_BUILD_FROM_SOURCE
@@ -36,12 +37,16 @@ public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
 #else
 
         private readonly SQLiteConnectionPoolService _connectionPoolService;
+        private readonly IAsynchronousOperationListener _asyncListener;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public DesktopPersistenceStorageServiceFactory(SQLiteConnectionPoolService connectionPoolService)
+        public DesktopPersistenceStorageServiceFactory(
+            SQLiteConnectionPoolService connectionPoolService,
+            IAsynchronousOperationListenerProvider asyncOperationListenerProvider)
         {
             _connectionPoolService = connectionPoolService;
+            _asyncListener = asyncOperationListenerProvider.GetListener(FeatureAttribute.PersistentStorage);
         }
 
         public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
@@ -55,7 +60,7 @@ public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
                 switch (database)
                 {
                     case StorageDatabase.SQLite:
-                        return new SQLitePersistentStorageService(options, _connectionPoolService, locationService);
+                        return new SQLitePersistentStorageService(options, _connectionPoolService, locationService, _asyncListener);
 
                     case StorageDatabase.CloudCache:
                         var factory = workspaceServices.GetService<ICloudCacheStorageServiceFactory>();
diff --git a/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorage.cs b/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorage.cs
index 418b29c4b8240..4b4970d5dc1e1 100644
--- a/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorage.cs
+++ b/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorage.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.PersistentStorage;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SQLite.v2.Interop;
 using Microsoft.CodeAnalysis.Storage;
 using Roslyn.Utilities;
@@ -45,6 +46,7 @@ private SQLitePersistentStorage(
             string workingFolderPath,
             string solutionFilePath,
             string databaseFile,
+            IAsynchronousOperationListener asyncListener,
             IPersistentStorageFaultInjector? faultInjector)
             : base(workingFolderPath, solutionFilePath, databaseFile)
         {
@@ -63,10 +65,10 @@ private SQLitePersistentStorage(
                 CancellationToken.None)!;
 
             // Create a delay to batch up requests to flush.  We'll won't flush more than every FlushAllDelayMS.
-            _flushQueue = new AsyncBatchingDelay(
+            _flushQueue = new AsyncBatchingWorkQueue(
                 TimeSpan.FromMilliseconds(FlushAllDelayMS),
                 FlushInMemoryDataToDiskIfNotShutdownAsync,
-                asyncListener: null,
+                asyncListener,
                 _shutdownTokenSource.Token);
         }
 
@@ -75,9 +77,11 @@ private SQLitePersistentStorage(
             string workingFolderPath,
             string solutionFilePath,
             string databaseFile,
+            IAsynchronousOperationListener asyncListener,
             IPersistentStorageFaultInjector? faultInjector)
         {
-            var sqlStorage = new SQLitePersistentStorage(connectionPoolService, workingFolderPath, solutionFilePath, databaseFile, faultInjector);
+            var sqlStorage = new SQLitePersistentStorage(
+                connectionPoolService, workingFolderPath, solutionFilePath, databaseFile, asyncListener, faultInjector);
             if (sqlStorage._connectionPool is null)
             {
                 // The connection pool failed to initialize
diff --git a/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorageService.cs b/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorageService.cs
index 9baaf0089c3ba..5b19565285155 100644
--- a/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorageService.cs
+++ b/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorageService.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PersistentStorage;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.SQLite.v2
@@ -19,25 +20,29 @@ internal class SQLitePersistentStorageService : AbstractSQLitePersistentStorageS
         private const string PersistentStorageFileName = "storage.ide";
 
         private readonly SQLiteConnectionPoolService _connectionPoolService;
+        private readonly IAsynchronousOperationListener _asyncListener;
         private readonly OptionSet _options;
         private readonly IPersistentStorageFaultInjector? _faultInjector;
 
         public SQLitePersistentStorageService(
             OptionSet options,
             SQLiteConnectionPoolService connectionPoolService,
-            IPersistentStorageLocationService locationService)
+            IPersistentStorageLocationService locationService,
+            IAsynchronousOperationListener asyncListener)
             : base(locationService)
         {
             _options = options;
             _connectionPoolService = connectionPoolService;
+            _asyncListener = asyncListener;
         }
 
         public SQLitePersistentStorageService(
             OptionSet options,
             SQLiteConnectionPoolService connectionPoolService,
             IPersistentStorageLocationService locationService,
+            IAsynchronousOperationListener asyncListener,
             IPersistentStorageFaultInjector? faultInjector)
-            : this(options, connectionPoolService, locationService)
+            : this(options, connectionPoolService, locationService, asyncListener)
         {
             _faultInjector = faultInjector;
         }
@@ -65,6 +70,7 @@ protected override string GetDatabaseFilePath(string workingFolderPath)
                 workingFolderPath,
                 solutionKey.FilePath,
                 databaseFilePath,
+                _asyncListener,
                 _faultInjector));
         }
 
diff --git a/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorage_FlushWrites.cs b/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorage_FlushWrites.cs
index 7bb665bd52a99..4389e046bda35 100644
--- a/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorage_FlushWrites.cs
+++ b/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorage_FlushWrites.cs
@@ -16,19 +16,19 @@ internal partial class SQLitePersistentStorage
         /// A queue to batch up flush requests and ensure that we don't issue then more often than every <see
         /// cref="FlushAllDelayMS"/>.
         /// </summary>
-        private readonly AsyncBatchingDelay _flushQueue;
+        private readonly AsyncBatchingWorkQueue _flushQueue;
 
         private void EnqueueFlushTask()
         {
-            _flushQueue.RequeueWork();
+            _flushQueue.AddWork();
         }
 
-        private Task FlushInMemoryDataToDiskIfNotShutdownAsync(CancellationToken cancellationToken)
+        private async ValueTask FlushInMemoryDataToDiskIfNotShutdownAsync(CancellationToken cancellationToken)
         {
             // When we are asked to flush, go actually acquire the write-scheduler and perform the actual writes from
             // it. Note: this is only called max every FlushAllDelayMS.  So we don't bother trying to avoid the delegate
             // allocation here.
-            return PerformWriteAsync(FlushInMemoryDataToDisk, cancellationToken);
+            await PerformWriteAsync(FlushInMemoryDataToDisk, cancellationToken).ConfigureAwait(false);
         }
 
         private Task FlushWritesOnCloseAsync()
diff --git a/src/Workspaces/Core/Portable/Workspace/Host/CompilationFactory/ICompilationFactoryService.cs b/src/Workspaces/Core/Portable/Workspace/Host/CompilationFactory/ICompilationFactoryService.cs
index 2140d43b72719..358cf9d40a6ae 100644
--- a/src/Workspaces/Core/Portable/Workspace/Host/CompilationFactory/ICompilationFactoryService.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Host/CompilationFactory/ICompilationFactoryService.cs
@@ -13,6 +13,6 @@ internal interface ICompilationFactoryService : ILanguageService
         Compilation CreateCompilation(string assemblyName, CompilationOptions options);
         Compilation CreateSubmissionCompilation(string assemblyName, CompilationOptions options, Type? hostObjectType);
         CompilationOptions GetDefaultCompilationOptions();
-        GeneratorDriver? CreateGeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider optionsProvider, ImmutableArray<AdditionalText> additionalTexts);
+        GeneratorDriver CreateGeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider optionsProvider, ImmutableArray<AdditionalText> additionalTexts);
     }
 }
diff --git a/src/Workspaces/Core/Portable/Workspace/Host/EventListener/EventListenerMetadata.cs b/src/Workspaces/Core/Portable/Workspace/Host/EventListener/EventListenerMetadata.cs
index 1d92e0042cdf6..51e54e6b4a3a7 100644
--- a/src/Workspaces/Core/Portable/Workspace/Host/EventListener/EventListenerMetadata.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Host/EventListener/EventListenerMetadata.cs
@@ -18,14 +18,14 @@ internal class EventListenerMetadata : WorkspaceKindMetadata
     {
         public string Service { get; }
 
-        public EventListenerMetadata(IDictionary<string, object> data) :
-            base(data)
+        public EventListenerMetadata(IDictionary<string, object> data)
+            : base(data)
         {
             this.Service = (string)data.GetValueOrDefault("Service");
         }
 
-        public EventListenerMetadata(string service, params string[] workspaceKinds) :
-            base(workspaceKinds)
+        public EventListenerMetadata(string service, params string[] workspaceKinds)
+            : base(workspaceKinds)
         {
             if (workspaceKinds?.Length == 0)
             {
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/AdditionalDocumentState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/AdditionalDocumentState.cs
new file mode 100644
index 0000000000000..1216a5261dc7f
--- /dev/null
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/AdditionalDocumentState.cs
@@ -0,0 +1,56 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class AdditionalDocumentState : TextDocumentState
+    {
+        private readonly AdditionalText _additionalText;
+
+        private AdditionalDocumentState(
+            SolutionServices solutionServices,
+            IDocumentServiceProvider documentServiceProvider,
+            DocumentInfo.DocumentAttributes attributes,
+            SourceText? sourceText,
+            ValueSource<TextAndVersion> textAndVersionSource)
+            : base(solutionServices, documentServiceProvider, attributes, sourceText, textAndVersionSource)
+        {
+            _additionalText = new AdditionalTextWithState(this);
+        }
+
+        public AdditionalDocumentState(
+            DocumentInfo documentInfo,
+            SolutionServices solutionServices)
+            : base(documentInfo, solutionServices)
+        {
+            _additionalText = new AdditionalTextWithState(this);
+        }
+
+        public AdditionalText AdditionalText => _additionalText;
+
+        public new AdditionalDocumentState UpdateText(TextLoader loader, PreservationMode mode)
+            => (AdditionalDocumentState)base.UpdateText(loader, mode);
+
+        public new AdditionalDocumentState UpdateText(SourceText text, PreservationMode mode)
+            => (AdditionalDocumentState)base.UpdateText(text, mode);
+
+        public new AdditionalDocumentState UpdateText(TextAndVersion newTextAndVersion, PreservationMode mode)
+            => (AdditionalDocumentState)base.UpdateText(newTextAndVersion, mode);
+
+        protected override TextDocumentState UpdateText(ValueSource<TextAndVersion> newTextSource, PreservationMode mode, bool incremental)
+        {
+            return new AdditionalDocumentState(
+                this.solutionServices,
+                this.Services,
+                this.Attributes,
+                this.sourceText,
+                newTextSource);
+        }
+    }
+}
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/AdditionalTextWithState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/AdditionalTextWithState.cs
index ab23b1b4a901c..bd2c335acc41f 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/AdditionalTextWithState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/AdditionalTextWithState.cs
@@ -9,16 +9,16 @@
 namespace Microsoft.CodeAnalysis.Diagnostics
 {
     /// <summary>
-    /// An implementation of <see cref="AdditionalText"/> for the compiler that wraps a <see cref="TextDocumentState"/>.
+    /// An implementation of <see cref="AdditionalText"/> for the compiler that wraps a <see cref="AdditionalDocumentState"/>.
     /// </summary>
     internal sealed class AdditionalTextWithState : AdditionalText
     {
-        private readonly TextDocumentState _documentState;
+        private readonly AdditionalDocumentState _documentState;
 
         /// <summary>
-        /// Create a <see cref="SourceText"/> from a <see cref="TextDocumentState"/>.
+        /// Create a <see cref="SourceText"/> from a <see cref="AdditionalDocumentState"/>.
         /// </summary>
-        public AdditionalTextWithState(TextDocumentState documentState)
+        public AdditionalTextWithState(AdditionalDocumentState documentState)
             => _documentState = documentState ?? throw new ArgumentNullException(nameof(documentState));
 
         /// <summary>
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/ChecksumCollection.cs b/src/Workspaces/Core/Portable/Workspace/Solution/ChecksumCollection.cs
index 7675cf7d47687..ef64b32826c87 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/ChecksumCollection.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/ChecksumCollection.cs
@@ -36,13 +36,14 @@ public IEnumerator<Checksum> GetEnumerator()
         IEnumerator IEnumerable.GetEnumerator()
             => GetEnumerator();
 
+        [PerformanceSensitive("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1333566", AllowGenericEnumeration = false)]
         internal static async Task FindAsync<TState>(
             TextDocumentStates<TState> documentStates,
             HashSet<Checksum> searchingChecksumsLeft,
             Dictionary<Checksum, object> result,
             CancellationToken cancellationToken) where TState : TextDocumentState
         {
-            foreach (var state in documentStates.States)
+            foreach (var (_, state) in documentStates.States)
             {
                 Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksums));
 
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
index 5f2e39a2f8fc6..2fcb8a0e4cba2 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
@@ -277,7 +277,7 @@ public async ValueTask<IEnumerable<SourceGeneratedDocument>> GetSourceGeneratedD
             var generatedDocumentStates = await _solution.State.GetSourceGeneratedDocumentStatesAsync(this.State, cancellationToken).ConfigureAwait(false);
 
             // return an iterator to avoid eagerly allocating all the document instances
-            return generatedDocumentStates.States.Select(state =>
+            return generatedDocumentStates.States.Values.Select(state =>
                 ImmutableHashMapExtensions.GetOrAdd(ref _idToSourceGeneratedDocumentMap, state.Id, s_createSourceGeneratedDocumentFunction, (state, this)))!;
         }
 
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState.cs
index 4c96f8797db96..cbb722776a0bb 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState.cs
@@ -35,7 +35,7 @@ internal partial class ProjectState
         /// The additional documents in this project. They are sorted by <see cref="DocumentId.Id"/> to provide a stable sort for
         /// <see cref="GetChecksumAsync(CancellationToken)"/>.
         /// </summary>
-        public readonly TextDocumentStates<TextDocumentState> AdditionalDocumentStates;
+        public readonly TextDocumentStates<AdditionalDocumentState> AdditionalDocumentStates;
 
         /// <summary>
         /// The analyzer config documents in this project.  They are sorted by <see cref="DocumentId.Id"/> to provide a stable sort for
@@ -66,7 +66,7 @@ private ProjectState(
             HostLanguageServices languageServices,
             SolutionServices solutionServices,
             TextDocumentStates<DocumentState> documentStates,
-            TextDocumentStates<TextDocumentState> additionalDocumentStates,
+            TextDocumentStates<AdditionalDocumentState> additionalDocumentStates,
             TextDocumentStates<AnalyzerConfigDocumentState> analyzerConfigDocumentStates,
             AsyncLazy<VersionStamp> lazyLatestDocumentVersion,
             AsyncLazy<VersionStamp> lazyLatestDocumentTopLevelChangeVersion,
@@ -116,7 +116,7 @@ public ProjectState(ProjectInfo projectInfo, HostLanguageServices languageServic
             var parseOptions = projectInfoFixed.ParseOptions;
 
             DocumentStates = new TextDocumentStates<DocumentState>(projectInfoFixed.Documents, info => CreateDocument(info, parseOptions));
-            AdditionalDocumentStates = new TextDocumentStates<TextDocumentState>(projectInfoFixed.AdditionalDocuments, info => new TextDocumentState(info, solutionServices));
+            AdditionalDocumentStates = new TextDocumentStates<AdditionalDocumentState>(projectInfoFixed.AdditionalDocuments, info => new AdditionalDocumentState(info, solutionServices));
 
             _lazyLatestDocumentVersion = new AsyncLazy<VersionStamp>(c => ComputeLatestDocumentVersionAsync(DocumentStates, AdditionalDocumentStates, c), cacheResult: true);
             _lazyLatestDocumentTopLevelChangeVersion = new AsyncLazy<VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(DocumentStates, AdditionalDocumentStates, c), cacheResult: true);
@@ -161,11 +161,11 @@ private ProjectInfo FixProjectInfo(ProjectInfo projectInfo)
             return projectInfo;
         }
 
-        private static async Task<VersionStamp> ComputeLatestDocumentVersionAsync(TextDocumentStates<DocumentState> documentStates, TextDocumentStates<TextDocumentState> additionalDocumentStates, CancellationToken cancellationToken)
+        private static async Task<VersionStamp> ComputeLatestDocumentVersionAsync(TextDocumentStates<DocumentState> documentStates, TextDocumentStates<AdditionalDocumentState> additionalDocumentStates, CancellationToken cancellationToken)
         {
             // this may produce a version that is out of sync with the actual Document versions.
             var latestVersion = VersionStamp.Default;
-            foreach (var state in documentStates.States)
+            foreach (var (_, state) in documentStates.States)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
@@ -176,7 +176,7 @@ private static async Task<VersionStamp> ComputeLatestDocumentVersionAsync(TextDo
                 }
             }
 
-            foreach (var state in additionalDocumentStates.States)
+            foreach (var (_, state) in additionalDocumentStates.States)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
@@ -190,7 +190,7 @@ private static async Task<VersionStamp> ComputeLatestDocumentVersionAsync(TextDo
         private AsyncLazy<VersionStamp> CreateLazyLatestDocumentTopLevelChangeVersion(
             TextDocumentState newDocument,
             TextDocumentStates<DocumentState> newDocumentStates,
-            TextDocumentStates<TextDocumentState> newAdditionalDocumentStates)
+            TextDocumentStates<AdditionalDocumentState> newAdditionalDocumentStates)
         {
             if (_lazyLatestDocumentTopLevelChangeVersion.TryGetValue(out var oldVersion))
             {
@@ -208,11 +208,11 @@ private static async Task<VersionStamp> ComputeTopLevelChangeTextVersionAsync(Ve
             return newVersion.GetNewerVersion(oldVersion);
         }
 
-        private static async Task<VersionStamp> ComputeLatestDocumentTopLevelChangeVersionAsync(TextDocumentStates<DocumentState> documentStates, TextDocumentStates<TextDocumentState> additionalDocumentStates, CancellationToken cancellationToken)
+        private static async Task<VersionStamp> ComputeLatestDocumentTopLevelChangeVersionAsync(TextDocumentStates<DocumentState> documentStates, TextDocumentStates<AdditionalDocumentState> additionalDocumentStates, CancellationToken cancellationToken)
         {
             // this may produce a version that is out of sync with the actual Document versions.
             var latestVersion = VersionStamp.Default;
-            foreach (var state in documentStates.States)
+            foreach (var (_, state) in documentStates.States)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
@@ -220,7 +220,7 @@ private static async Task<VersionStamp> ComputeLatestDocumentTopLevelChangeVersi
                 latestVersion = version.GetNewerVersion(latestVersion);
             }
 
-            foreach (var state in additionalDocumentStates.States)
+            foreach (var (_, state) in additionalDocumentStates.States)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
@@ -245,7 +245,7 @@ internal DocumentState CreateDocument(DocumentInfo documentInfo, ParseOptions? p
 
         public AnalyzerOptions AnalyzerOptions
             => _lazyAnalyzerOptions ??= new AnalyzerOptions(
-                additionalFiles: AdditionalDocumentStates.SelectAsArray<AdditionalText>(static state => new AdditionalTextWithState(state)),
+                additionalFiles: AdditionalDocumentStates.SelectAsArray(static documentState => documentState.AdditionalText),
                 optionsProvider: new WorkspaceAnalyzerConfigOptionsProvider(this));
 
         public async Task<ImmutableDictionary<string, string>> GetAnalyzerOptionsForPathAsync(
@@ -364,7 +364,7 @@ private static ValueSource<CachingAnalyzerConfigSet> ComputeAnalyzerConfigSetVal
             return new AsyncLazy<CachingAnalyzerConfigSet>(
                 asynchronousComputeFunction: async cancellationToken =>
                 {
-                    var tasks = analyzerConfigDocumentStates.States.Select(a => a.GetAnalyzerConfigAsync(cancellationToken));
+                    var tasks = analyzerConfigDocumentStates.States.Values.Select(a => a.GetAnalyzerConfigAsync(cancellationToken));
                     var analyzerConfigs = await Task.WhenAll(tasks).ConfigureAwait(false);
 
                     cancellationToken.ThrowIfCancellationRequested();
@@ -461,7 +461,7 @@ public async Task<VersionStamp> GetSemanticVersionAsync(CancellationToken cancel
         private ProjectState With(
             ProjectInfo? projectInfo = null,
             TextDocumentStates<DocumentState>? documentStates = null,
-            TextDocumentStates<TextDocumentState>? additionalDocumentStates = null,
+            TextDocumentStates<AdditionalDocumentState>? additionalDocumentStates = null,
             TextDocumentStates<AnalyzerConfigDocumentState>? analyzerConfigDocumentStates = null,
             AsyncLazy<VersionStamp>? latestDocumentVersion = null,
             AsyncLazy<VersionStamp>? latestDocumentTopLevelChangeVersion = null,
@@ -609,7 +609,7 @@ public ProjectState AddDocuments(ImmutableArray<DocumentState> documents)
                 documentStates: DocumentStates.AddRange(documents));
         }
 
-        public ProjectState AddAdditionalDocuments(ImmutableArray<TextDocumentState> documents)
+        public ProjectState AddAdditionalDocuments(ImmutableArray<AdditionalDocumentState> documents)
         {
             Debug.Assert(!documents.Any(d => AdditionalDocumentStates.Contains(d.Id)));
 
@@ -699,7 +699,7 @@ public ProjectState UpdateDocument(DocumentState newDocument, bool textChanged,
                 latestDocumentTopLevelChangeVersion: dependentSemanticVersion);
         }
 
-        public ProjectState UpdateAdditionalDocument(TextDocumentState newDocument, bool textChanged, bool recalculateDependentVersions)
+        public ProjectState UpdateAdditionalDocument(AdditionalDocumentState newDocument, bool textChanged, bool recalculateDependentVersions)
         {
             var oldDocument = AdditionalDocumentStates.GetRequiredState(newDocument.Id);
             if (oldDocument == newDocument)
@@ -745,7 +745,7 @@ public ProjectState UpdateDocumentsOrder(ImmutableList<DocumentId> documentIds)
 
         private void GetLatestDependentVersions(
             TextDocumentStates<DocumentState> newDocumentStates,
-            TextDocumentStates<TextDocumentState> newAdditionalDocumentStates,
+            TextDocumentStates<AdditionalDocumentState> newAdditionalDocumentStates,
             TextDocumentState oldDocument, TextDocumentState newDocument,
             bool recalculateDependentVersions, bool textChanged,
             out AsyncLazy<VersionStamp> dependentDocumentVersion, out AsyncLazy<VersionStamp> dependentSemanticVersion)
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationAndGeneratorDriverTranslationAction.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationAndGeneratorDriverTranslationAction.cs
index 3af5e1a6c1c03..92e824fcc101b 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationAndGeneratorDriverTranslationAction.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationAndGeneratorDriverTranslationAction.cs
@@ -9,6 +9,10 @@ namespace Microsoft.CodeAnalysis
 {
     internal partial class SolutionState
     {
+        /// <summary>
+        /// Represents a change that needs to be made to a <see cref="Compilation"/>, <see cref="GeneratorDriver"/>, or both in response to
+        /// some user edit.
+        /// </summary>
         private abstract partial class CompilationAndGeneratorDriverTranslationAction
         {
             public virtual Task<Compilation> TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken)
@@ -28,6 +32,8 @@ public virtual Task<Compilation> TransformCompilationAsync(Compilation oldCompil
             /// </remarks>
             public abstract bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput { get; }
 
+            public virtual GeneratorDriver? TransformGeneratorDriver(GeneratorDriver generatorDriver) => generatorDriver;
+
             /// <summary>
             /// When changes are made to a solution, we make a list of translation actions. If multiple similar changes happen in rapid
             /// succession, we may be able to merge them without holding onto intermediate state.
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationAndGeneratorDriverTranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationAndGeneratorDriverTranslationAction_Actions.cs
index 1ae69d5f48c37..c316cc133c361 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationAndGeneratorDriverTranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationAndGeneratorDriverTranslationAction_Actions.cs
@@ -4,9 +4,12 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis
 {
@@ -50,13 +53,10 @@ public override Task<Compilation> TransformCompilationAsync(Compilation oldCompi
 
             internal sealed class TouchAdditionalDocumentAction : CompilationAndGeneratorDriverTranslationAction
             {
-#pragma warning disable IDE0052 // Remove unread private members
-                // https://github.com/dotnet/roslyn/issues/44161: right now there is no way to tell a GeneratorDriver that an additional document changed
-                private readonly TextDocumentState _oldState;
-                private readonly TextDocumentState _newState;
-#pragma warning restore IDE0052 // Remove unread private members
+                private readonly AdditionalDocumentState _oldState;
+                private readonly AdditionalDocumentState _newState;
 
-                public TouchAdditionalDocumentAction(TextDocumentState oldState, TextDocumentState newState)
+                public TouchAdditionalDocumentAction(AdditionalDocumentState oldState, AdditionalDocumentState newState)
                 {
                     _oldState = oldState;
                     _newState = newState;
@@ -77,6 +77,14 @@ public TouchAdditionalDocumentAction(TextDocumentState oldState, TextDocumentSta
 
                     return null;
                 }
+
+                public override GeneratorDriver? TransformGeneratorDriver(GeneratorDriver generatorDriver)
+                {
+                    var oldText = _oldState.AdditionalText;
+                    var newText = _newState.AdditionalText;
+
+                    return generatorDriver.ReplaceAdditionalText(oldText, newText);
+                }
             }
 
             internal sealed class RemoveDocumentsAction : CompilationAndGeneratorDriverTranslationAction
@@ -132,10 +140,12 @@ public override async Task<Compilation> TransformCompilationAsync(Compilation ol
             internal sealed class ReplaceAllSyntaxTreesAction : CompilationAndGeneratorDriverTranslationAction
             {
                 private readonly ProjectState _state;
+                private readonly bool _isParseOptionChange;
 
-                public ReplaceAllSyntaxTreesAction(ProjectState state)
+                public ReplaceAllSyntaxTreesAction(ProjectState state, bool isParseOptionChange)
                 {
                     _state = state;
+                    _isParseOptionChange = isParseOptionChange;
                 }
 
                 public override async Task<Compilation> TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken)
@@ -153,25 +163,57 @@ public override async Task<Compilation> TransformCompilationAsync(Compilation ol
 
                 // Because this removes all trees, it'd also remove the generated trees.
                 public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => false;
+
+                public override GeneratorDriver? TransformGeneratorDriver(GeneratorDriver generatorDriver)
+                {
+                    if (_isParseOptionChange)
+                    {
+                        RoslynDebug.AssertNotNull(_state.ParseOptions);
+                        return generatorDriver.WithUpdatedParseOptions(_state.ParseOptions);
+                    }
+                    else
+                    {
+                        // We are using this as a way to reorder syntax trees -- we don't need to do anything as the driver
+                        // will get the new compilation once we pass it to it.
+                        return generatorDriver;
+                    }
+                }
             }
 
             internal sealed class ProjectCompilationOptionsAction : CompilationAndGeneratorDriverTranslationAction
             {
-                private readonly CompilationOptions _options;
+                private readonly ProjectState _state;
+                private readonly bool _isAnalyzerConfigChange;
 
-                public ProjectCompilationOptionsAction(CompilationOptions options)
+                public ProjectCompilationOptionsAction(ProjectState state, bool isAnalyzerConfigChange)
                 {
-                    _options = options;
+                    _state = state;
+                    _isAnalyzerConfigChange = isAnalyzerConfigChange;
                 }
 
                 public override Task<Compilation> TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken)
                 {
-                    return Task.FromResult(oldCompilation.WithOptions(_options));
+                    RoslynDebug.AssertNotNull(_state.CompilationOptions);
+                    return Task.FromResult(oldCompilation.WithOptions(_state.CompilationOptions));
                 }
 
                 // Updating the options of a compilation doesn't require us to reparse trees, so we can use this to update
                 // compilations with stale generated trees.
                 public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => true;
+
+                public override GeneratorDriver? TransformGeneratorDriver(GeneratorDriver generatorDriver)
+                {
+                    if (_isAnalyzerConfigChange)
+                    {
+                        return generatorDriver.WithUpdatedAnalyzerConfigOptions(_state.AnalyzerOptions.AnalyzerConfigOptionsProvider);
+                    }
+                    else
+                    {
+                        // Changing any other option is fine and the driver can be reused. The driver
+                        // will get the new compilation once we pass it to it.
+                        return generatorDriver;
+                    }
+                }
             }
 
             internal sealed class ProjectAssemblyNameAction : CompilationAndGeneratorDriverTranslationAction
@@ -195,11 +237,8 @@ public override Task<Compilation> TransformCompilationAsync(Compilation oldCompi
 
             internal sealed class AddAnalyzerReferencesAction : CompilationAndGeneratorDriverTranslationAction
             {
-#pragma warning disable IDE0052 // Remove unread private members
-                // https://github.com/dotnet/roslyn/issues/44161: right now there is no way to tell a GeneratorDriver that an analyzer reference has been added
                 private readonly ImmutableArray<AnalyzerReference> _analyzerReferences;
                 private readonly string _language;
-#pragma warning restore IDE0052 // Remove unread private members
 
                 public AddAnalyzerReferencesAction(ImmutableArray<AnalyzerReference> analyzerReferences, string language)
                 {
@@ -211,15 +250,17 @@ public AddAnalyzerReferencesAction(ImmutableArray<AnalyzerReference> analyzerRef
                 // translation (which is a no-op). Since we use a 'false' here to mean that it's not worth keeping
                 // the compilation with stale trees around, answering true is still important.
                 public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => true;
+
+                public override GeneratorDriver? TransformGeneratorDriver(GeneratorDriver generatorDriver)
+                {
+                    return generatorDriver.AddGenerators(_analyzerReferences.SelectMany(r => r.GetGenerators(_language)).ToImmutableArray());
+                }
             }
 
             internal sealed class RemoveAnalyzerReferencesAction : CompilationAndGeneratorDriverTranslationAction
             {
-#pragma warning disable IDE0052 // Remove unread private members
-                // https://github.com/dotnet/roslyn/issues/44161: right now there is no way to tell a GeneratorDriver that an analyzer reference has been removed
                 private readonly ImmutableArray<AnalyzerReference> _analyzerReferences;
                 private readonly string _language;
-#pragma warning restore IDE0052 // Remove unread private members
 
                 public RemoveAnalyzerReferencesAction(ImmutableArray<AnalyzerReference> analyzerReferences, string language)
                 {
@@ -231,16 +272,17 @@ public RemoveAnalyzerReferencesAction(ImmutableArray<AnalyzerReference> analyzer
                 // translation (which is a no-op). Since we use a 'false' here to mean that it's not worth keeping
                 // the compilation with stale trees around, answering true is still important.
                 public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => true;
+                public override GeneratorDriver? TransformGeneratorDriver(GeneratorDriver generatorDriver)
+                {
+                    return generatorDriver.RemoveGenerators(_analyzerReferences.SelectMany(r => r.GetGenerators(_language)).ToImmutableArray());
+                }
             }
 
             internal sealed class AddAdditionalDocumentsAction : CompilationAndGeneratorDriverTranslationAction
             {
-#pragma warning disable IDE0052 // Remove unread private members
-                // https://github.com/dotnet/roslyn/issues/44161: right now there is no way to tell a GeneratorDriver that an additional file has been added
-                private readonly ImmutableArray<TextDocumentState> _additionalDocuments;
-#pragma warning restore IDE0052 // Remove unread private members
+                private readonly ImmutableArray<AdditionalDocumentState> _additionalDocuments;
 
-                public AddAdditionalDocumentsAction(ImmutableArray<TextDocumentState> additionalDocuments)
+                public AddAdditionalDocumentsAction(ImmutableArray<AdditionalDocumentState> additionalDocuments)
                 {
                     _additionalDocuments = additionalDocuments;
                 }
@@ -249,16 +291,18 @@ public AddAdditionalDocumentsAction(ImmutableArray<TextDocumentState> additional
                 // translation (which is a no-op). Since we use a 'false' here to mean that it's not worth keeping
                 // the compilation with stale trees around, answering true is still important.
                 public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => true;
+
+                public override GeneratorDriver? TransformGeneratorDriver(GeneratorDriver generatorDriver)
+                {
+                    return generatorDriver.AddAdditionalTexts(_additionalDocuments.SelectAsArray(static documentState => documentState.AdditionalText));
+                }
             }
 
             internal sealed class RemoveAdditionalDocumentsAction : CompilationAndGeneratorDriverTranslationAction
             {
-#pragma warning disable IDE0052 // Remove unread private members
-                // https://github.com/dotnet/roslyn/issues/44161: right now there is no way to tell a GeneratorDriver that an additional file has been added
-                private readonly ImmutableArray<TextDocumentState> _additionalDocuments;
-#pragma warning restore IDE0052 // Remove unread private members
+                private readonly ImmutableArray<AdditionalDocumentState> _additionalDocuments;
 
-                public RemoveAdditionalDocumentsAction(ImmutableArray<TextDocumentState> additionalDocuments)
+                public RemoveAdditionalDocumentsAction(ImmutableArray<AdditionalDocumentState> additionalDocuments)
                 {
                     _additionalDocuments = additionalDocuments;
                 }
@@ -267,6 +311,11 @@ public RemoveAdditionalDocumentsAction(ImmutableArray<TextDocumentState> additio
                 // translation (which is a no-op). Since we use a 'false' here to mean that it's not worth keeping
                 // the compilation with stale trees around, answering true is still important.
                 public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => true;
+
+                public override GeneratorDriver? TransformGeneratorDriver(GeneratorDriver generatorDriver)
+                {
+                    return generatorDriver.RemoveAdditionalTexts(_additionalDocuments.SelectAsArray(static documentState => documentState.AdditionalText));
+                }
             }
         }
     }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.State.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.State.cs
index 96ee1b8160480..b03e5a92a2f8a 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.State.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.State.cs
@@ -31,7 +31,8 @@ private class State
                     compilationWithoutGeneratedDocuments: null,
                     declarationOnlyCompilation: null,
                     generatedDocuments: TextDocumentStates<SourceGeneratedDocumentState>.Empty,
-                    generatedDocumentsAreFinal: false);
+                    generatedDocumentsAreFinal: false,
+                    generatorDriver: null);
 
                 /// <summary>
                 /// A strong reference to the declaration-only compilation. This compilation isn't used to produce symbols,
@@ -53,6 +54,13 @@ private class State
                 /// </summary>
                 public TextDocumentStates<SourceGeneratedDocumentState> GeneratedDocuments { get; }
 
+                /// <summary>
+                /// The <see cref="GeneratorDriver"/> that was used for the last run, to allow for incremental reuse. May be null
+                /// if we don't have generators in the first place, haven't ran generators yet for this project, or had to get rid of our
+                /// driver for some reason.
+                /// </summary>
+                public GeneratorDriver? GeneratorDriver { get; }
+
                 /// <summary>
                 /// Whether the generated documents in <see cref="GeneratedDocuments"/> are final and should not be regenerated. It's important
                 /// that once we've ran generators once we don't want to run them again. Once we've ran them the first time, those syntax trees
@@ -78,6 +86,7 @@ protected State(
                     ValueSource<Optional<Compilation>>? compilationWithoutGeneratedDocuments,
                     Compilation? declarationOnlyCompilation,
                     TextDocumentStates<SourceGeneratedDocumentState> generatedDocuments,
+                    GeneratorDriver? generatorDriver,
                     bool generatedDocumentsAreFinal)
                 {
                     // Declaration-only compilations should never have any references
@@ -86,12 +95,14 @@ protected State(
                     CompilationWithoutGeneratedDocuments = compilationWithoutGeneratedDocuments;
                     DeclarationOnlyCompilation = declarationOnlyCompilation;
                     GeneratedDocuments = generatedDocuments;
+                    GeneratorDriver = generatorDriver;
                     GeneratedDocumentsAreFinal = generatedDocumentsAreFinal;
                 }
 
                 public static State Create(
                     Compilation compilation,
                     TextDocumentStates<SourceGeneratedDocumentState> generatedDocuments,
+                    GeneratorDriver? generatorDriver,
                     Compilation? compilationWithGeneratedDocuments,
                     ImmutableArray<ValueTuple<ProjectState, CompilationAndGeneratorDriverTranslationAction>> intermediateProjects)
                 {
@@ -101,8 +112,8 @@ public static State Create(
                     // DeclarationState now. We'll pass false for generatedDocumentsAreFinal because this is being called
                     // if our referenced projects are changing, so we'll have to rerun to consume changes.
                     return intermediateProjects.Length == 0
-                        ? new FullDeclarationState(compilation, generatedDocuments, generatedDocumentsAreFinal: false)
-                        : (State)new InProgressState(compilation, generatedDocuments, compilationWithGeneratedDocuments, intermediateProjects);
+                        ? new FullDeclarationState(compilation, generatedDocuments, generatorDriver, generatedDocumentsAreFinal: false)
+                        : new InProgressState(compilation, generatedDocuments, generatorDriver, compilationWithGeneratedDocuments, intermediateProjects);
                 }
 
                 public static ValueSource<Optional<Compilation>> CreateValueSource(
@@ -138,11 +149,13 @@ private sealed class InProgressState : State
                 public InProgressState(
                     Compilation inProgressCompilation,
                     TextDocumentStates<SourceGeneratedDocumentState> generatedDocuments,
+                    GeneratorDriver? generatorDriver,
                     Compilation? compilationWithGeneratedDocuments,
                     ImmutableArray<(ProjectState state, CompilationAndGeneratorDriverTranslationAction action)> intermediateProjects)
                     : base(compilationWithoutGeneratedDocuments: new ConstantValueSource<Optional<Compilation>>(inProgressCompilation),
                            declarationOnlyCompilation: null,
                            generatedDocuments,
+                           generatorDriver,
                            generatedDocumentsAreFinal: false) // since we have a set of transformations to make, we'll always have to run generators again
                 {
                     Contract.ThrowIfTrue(intermediateProjects.IsDefault);
@@ -160,10 +173,12 @@ private sealed class LightDeclarationState : State
             {
                 public LightDeclarationState(Compilation declarationOnlyCompilation,
                     TextDocumentStates<SourceGeneratedDocumentState> generatedDocuments,
+                    GeneratorDriver? generatorDriver,
                     bool generatedDocumentsAreFinal)
                     : base(compilationWithoutGeneratedDocuments: null,
                            declarationOnlyCompilation,
                            generatedDocuments,
+                           generatorDriver,
                            generatedDocumentsAreFinal)
                 {
                 }
@@ -177,10 +192,12 @@ private sealed class FullDeclarationState : State
             {
                 public FullDeclarationState(Compilation declarationCompilation,
                     TextDocumentStates<SourceGeneratedDocumentState> generatedDocuments,
+                    GeneratorDriver? generatorDriver,
                     bool generatedDocumentsAreFinal)
                     : base(new WeakValueSource<Compilation>(declarationCompilation),
                            declarationCompilation.Clone().RemoveAllReferences(),
                            generatedDocuments,
+                           generatorDriver,
                            generatedDocumentsAreFinal)
                 {
                 }
@@ -224,10 +241,12 @@ private FinalState(
                     Compilation compilationWithoutGeneratedFiles,
                     bool hasSuccessfullyLoaded,
                     TextDocumentStates<SourceGeneratedDocumentState> generatedDocuments,
+                    GeneratorDriver? generatorDriver,
                     UnrootedSymbolSet unrootedSymbolSet)
                     : base(compilationWithoutGeneratedFilesSource,
                            compilationWithoutGeneratedFiles.Clone().RemoveAllReferences(),
                            generatedDocuments,
+                           generatorDriver: generatorDriver,
                            generatedDocumentsAreFinal: true) // when we're in a final state, we've ran generators and should not run again
                 {
                     HasSuccessfullyLoaded = hasSuccessfullyLoaded;
@@ -252,6 +271,7 @@ public static FinalState Create(
                     Compilation compilationWithoutGeneratedFiles,
                     bool hasSuccessfullyLoaded,
                     TextDocumentStates<SourceGeneratedDocumentState> generatedDocuments,
+                    GeneratorDriver? generatorDriver,
                     Compilation finalCompilation,
                     ProjectId projectId,
                     Dictionary<MetadataReference, ProjectId>? metadataReferenceToProjectId)
@@ -267,7 +287,9 @@ public static FinalState Create(
                         compilationWithoutGeneratedFilesSource,
                         compilationWithoutGeneratedFiles,
                         hasSuccessfullyLoaded,
-                        generatedDocuments, unrootedSymbolSet);
+                        generatedDocuments,
+                        generatorDriver,
+                        unrootedSymbolSet);
                 }
 
                 private static void RecordAssemblySymbols(ProjectId projectId, Compilation compilation, Dictionary<MetadataReference, ProjectId>? metadataReferenceToProjectId)
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
index 1ccf65b54804c..eaab5fc8f7178 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
@@ -155,7 +155,7 @@ public ICompilationTracker Fork(
                         }
                     }
 
-                    var newState = State.Create(newInProgressCompilation, state.GeneratedDocuments, state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken), intermediateProjects);
+                    var newState = State.Create(newInProgressCompilation, state.GeneratedDocuments, state.GeneratorDriver, state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken), intermediateProjects);
 
                     return new CompilationTracker(newProject, newState);
                 }
@@ -166,10 +166,10 @@ public ICompilationTracker Fork(
                     if (translate != null)
                     {
                         var intermediateProjects = ImmutableArray.Create((this.ProjectState, translate));
-                        return new CompilationTracker(newProject, new InProgressState(declarationOnlyCompilation, state.GeneratedDocuments, compilationWithGeneratedDocuments: state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken), intermediateProjects));
+                        return new CompilationTracker(newProject, new InProgressState(declarationOnlyCompilation, state.GeneratedDocuments, state.GeneratorDriver, compilationWithGeneratedDocuments: state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken), intermediateProjects));
                     }
 
-                    return new CompilationTracker(newProject, new LightDeclarationState(declarationOnlyCompilation, state.GeneratedDocuments, generatedDocumentsAreFinal: false));
+                    return new CompilationTracker(newProject, new LightDeclarationState(declarationOnlyCompilation, state.GeneratedDocuments, state.GeneratorDriver, generatedDocumentsAreFinal: false));
                 }
 
                 // We have nothing.  Just make a tracker that only points to the new project.  We'll have
@@ -188,7 +188,7 @@ public ICompilationTracker FreezePartialStateWithTree(SolutionState solution, Do
                 GetPartialCompilationState(
                     solution, docState.Id,
                     out var inProgressProject, out var inProgressCompilation,
-                    out var sourceGeneratedDocuments, out var metadataReferenceToProjectId, cancellationToken);
+                    out var sourceGeneratedDocuments, out var generatorDriver, out var metadataReferenceToProjectId, cancellationToken);
 
                 if (!inProgressCompilation.SyntaxTrees.Contains(tree))
                 {
@@ -215,6 +215,7 @@ public ICompilationTracker FreezePartialStateWithTree(SolutionState solution, Do
                     inProgressCompilation,
                     hasSuccessfullyLoaded: false,
                     sourceGeneratedDocuments,
+                    generatorDriver,
                     inProgressCompilation,
                     this.ProjectState.Id,
                     metadataReferenceToProjectId);
@@ -238,6 +239,7 @@ private void GetPartialCompilationState(
                 out ProjectState inProgressProject,
                 out Compilation inProgressCompilation,
                 out TextDocumentStates<SourceGeneratedDocumentState> sourceGeneratedDocuments,
+                out GeneratorDriver? generatorDriver,
                 out Dictionary<MetadataReference, ProjectId>? metadataReferenceToProjectId,
                 CancellationToken cancellationToken)
             {
@@ -248,6 +250,7 @@ private void GetPartialCompilationState(
                 var inProgressState = state as InProgressState;
 
                 sourceGeneratedDocuments = state.GeneratedDocuments;
+                generatorDriver = state.GeneratorDriver;
 
                 // all changes left for this document is modifying the given document.
                 // we can use current state as it is since we will replace the document with latest document anyway.
@@ -259,7 +262,7 @@ private void GetPartialCompilationState(
 
                     // We'll add in whatever generated documents we do have; these may be from a prior run prior to some changes
                     // being made to the project, but it's the best we have so we'll use it.
-                    inProgressCompilation = compilationWithoutGeneratedDocuments.AddSyntaxTrees(sourceGeneratedDocuments.States.Select(state => state.GetSyntaxTree(cancellationToken)));
+                    inProgressCompilation = compilationWithoutGeneratedDocuments.AddSyntaxTrees(sourceGeneratedDocuments.States.Values.Select(state => state.GetSyntaxTree(cancellationToken)));
 
                     // This is likely a bug.  It seems possible to pass out a partial compilation state that we don't
                     // properly record assembly symbols for.
@@ -302,7 +305,7 @@ private void GetPartialCompilationState(
                     inProgressCompilation = compilationWithoutGeneratedDocuments;
                 }
 
-                inProgressCompilation = inProgressCompilation.AddSyntaxTrees(sourceGeneratedDocuments.States.Select(state => state.GetSyntaxTree(cancellationToken)));
+                inProgressCompilation = inProgressCompilation.AddSyntaxTrees(sourceGeneratedDocuments.States.Values.Select(state => state.GetSyntaxTree(cancellationToken)));
 
                 // Now add in back a consistent set of project references.  For project references
                 // try to get either a CompilationReference or a SkeletonReference. This ensures
@@ -429,7 +432,7 @@ private async Task<Compilation> GetOrBuildDeclarationCompilationAsync(SolutionSe
                                 // okay, move to full declaration state. do this so that declaration only compilation never
                                 // realize symbols.
                                 var declarationOnlyCompilation = state.DeclarationOnlyCompilation.Clone();
-                                WriteState(new FullDeclarationState(declarationOnlyCompilation, state.GeneratedDocuments, state.GeneratedDocumentsAreFinal), solutionServices);
+                                WriteState(new FullDeclarationState(declarationOnlyCompilation, state.GeneratedDocuments, state.GeneratorDriver, state.GeneratedDocumentsAreFinal), solutionServices);
                                 return declarationOnlyCompilation;
                             }
 
@@ -443,7 +446,7 @@ private async Task<Compilation> GetOrBuildDeclarationCompilationAsync(SolutionSe
                             return compilation;
                         }
 
-                        (compilation, _) = await BuildDeclarationCompilationFromInProgressAsync(solutionServices, (InProgressState)state, compilation, cancellationToken).ConfigureAwait(false);
+                        (compilation, _, _) = await BuildDeclarationCompilationFromInProgressAsync(solutionServices, (InProgressState)state, compilation, cancellationToken).ConfigureAwait(false);
 
                         // We must have an in progress compilation. Build off of that.
                         return compilation;
@@ -525,8 +528,8 @@ private Task<CompilationInfo> BuildCompilationInfoAsync(
                 // so we can pass those to FinalizeCompilationAsync to avoid the recomputation. This is necessary for correctness as otherwise
                 // we'd be reparsing trees which could result in generated documents changing identity.
                 var authoritativeGeneratedDocuments = state.GeneratedDocumentsAreFinal ? state.GeneratedDocuments : (TextDocumentStates<SourceGeneratedDocumentState>?)null;
-
                 var nonAuthoritativeGeneratedDocuments = state.GeneratedDocuments;
+                var generatorDriver = state.GeneratorDriver;
 
                 if (compilation == null)
                 {
@@ -535,7 +538,7 @@ private Task<CompilationInfo> BuildCompilationInfoAsync(
                     if (state.DeclarationOnlyCompilation != null)
                     {
                         // we have declaration only compilation. build final one from it.
-                        return FinalizeCompilationAsync(solution, state.DeclarationOnlyCompilation, authoritativeGeneratedDocuments, nonAuthoritativeGeneratedDocuments, compilationWithStaleGeneratedTrees: null, cancellationToken);
+                        return FinalizeCompilationAsync(solution, state.DeclarationOnlyCompilation, authoritativeGeneratedDocuments, nonAuthoritativeGeneratedDocuments, compilationWithStaleGeneratedTrees: null, generatorDriver, cancellationToken);
                     }
 
                     // We've got nothing.  Build it from scratch :(
@@ -551,6 +554,7 @@ private Task<CompilationInfo> BuildCompilationInfoAsync(
                         authoritativeGeneratedDocuments,
                         nonAuthoritativeGeneratedDocuments,
                         compilationWithStaleGeneratedTrees: null,
+                        generatorDriver,
                         cancellationToken);
                 }
                 else
@@ -572,6 +576,7 @@ private async Task<CompilationInfo> BuildCompilationInfoFromScratchAsync(
                         authoritativeGeneratedDocuments: null,
                         nonAuthoritativeGeneratedDocuments: TextDocumentStates<SourceGeneratedDocumentState>.Empty,
                         compilationWithStaleGeneratedTrees: null,
+                        generatorDriver: null,
                         cancellationToken).ConfigureAwait(false);
                 }
                 catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
@@ -601,7 +606,7 @@ private async Task<Compilation> BuildDeclarationCompilationFromScratchAsync(
                     compilation = compilation.AddSyntaxTrees(trees);
                     trees.Free();
 
-                    WriteState(new FullDeclarationState(compilation, TextDocumentStates<SourceGeneratedDocumentState>.Empty, generatedDocumentsAreFinal: false), solutionServices);
+                    WriteState(new FullDeclarationState(compilation, TextDocumentStates<SourceGeneratedDocumentState>.Empty, generatorDriver: null, generatedDocumentsAreFinal: false), solutionServices);
                     return compilation;
                 }
                 catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
@@ -634,8 +639,15 @@ private async Task<CompilationInfo> BuildFinalStateFromInProgressStateAsync(
             {
                 try
                 {
-                    var (compilationWithoutGenerators, compilationWithGenerators) = await BuildDeclarationCompilationFromInProgressAsync(solution.Services, state, inProgressCompilation, cancellationToken).ConfigureAwait(false);
-                    return await FinalizeCompilationAsync(solution, compilationWithoutGenerators, authoritativeGeneratedDocuments: null, nonAuthoritativeGeneratedDocuments: state.GeneratedDocuments, compilationWithGenerators, cancellationToken).ConfigureAwait(false);
+                    var (compilationWithoutGenerators, compilationWithGenerators, generatorDriver) = await BuildDeclarationCompilationFromInProgressAsync(solution.Services, state, inProgressCompilation, cancellationToken).ConfigureAwait(false);
+                    return await FinalizeCompilationAsync(
+                        solution,
+                        compilationWithoutGenerators,
+                        authoritativeGeneratedDocuments: null,
+                        nonAuthoritativeGeneratedDocuments: state.GeneratedDocuments,
+                        compilationWithGenerators,
+                        generatorDriver,
+                        cancellationToken).ConfigureAwait(false);
                 }
                 catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
                 {
@@ -643,12 +655,13 @@ private async Task<CompilationInfo> BuildFinalStateFromInProgressStateAsync(
                 }
             }
 
-            private async Task<(Compilation compilationWithoutGenerators, Compilation? compilationWithGenerators)> BuildDeclarationCompilationFromInProgressAsync(
+            private async Task<(Compilation compilationWithoutGenerators, Compilation? compilationWithGenerators, GeneratorDriver? generatorDriver)> BuildDeclarationCompilationFromInProgressAsync(
                 SolutionServices solutionServices, InProgressState state, Compilation compilationWithoutGenerators, CancellationToken cancellationToken)
             {
                 try
                 {
                     var compilationWithGenerators = state.CompilationWithGeneratedDocuments;
+                    var generatorDriver = state.GeneratorDriver;
 
                     // If compilationWithGenerators is the same as compilationWithoutGenerators, then it means a prior run of generators
                     // didn't produce any files. In that case, we'll just make compilationWithGenerators null so we avoid doing any
@@ -686,14 +699,19 @@ private async Task<CompilationInfo> BuildFinalStateFromInProgressStateAsync(
                             }
                         }
 
+                        if (generatorDriver != null)
+                        {
+                            generatorDriver = intermediateProject.action.TransformGeneratorDriver(generatorDriver);
+                        }
+
                         // We have updated state, so store this new result; this allows us to drop the intermediate state we already processed
                         // even if we were to get cancelled at a later point.
                         intermediateProjects = intermediateProjects.RemoveAt(0);
 
-                        this.WriteState(State.Create(compilationWithoutGenerators, state.GeneratedDocuments, compilationWithGenerators, intermediateProjects), solutionServices);
+                        this.WriteState(State.Create(compilationWithoutGenerators, state.GeneratedDocuments, generatorDriver, compilationWithGenerators, intermediateProjects), solutionServices);
                     }
 
-                    return (compilationWithoutGenerators, compilationWithGenerators);
+                    return (compilationWithoutGenerators, compilationWithGenerators, generatorDriver);
                 }
                 catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
                 {
@@ -726,12 +744,19 @@ public CompilationInfo(Compilation compilation, bool hasSuccessfullyLoaded, Text
             /// <param name="nonAuthoritativeGeneratedDocuments">The generated documents from a previous pass which may
             /// or may not be correct for the current compilation. These states may be used to access cached results, if
             /// and when applicable for the current compilation.</param>
+            /// <param name="compilationWithStaleGeneratedTrees">The compilation from a prior run that contains generated trees, which
+            /// match the states included in <paramref name="nonAuthoritativeGeneratedDocuments"/>. If a generator run here produces
+            /// the same set of generated documents as are in <paramref name="nonAuthoritativeGeneratedDocuments"/>, and we don't need to make any other
+            /// changes to references, we can then use this compilation instead of re-adding source generated files again to the
+            /// <paramref name="compilationWithoutGenerators"/>.</param>
+            /// <param name="generatorDriver">The generator driver that can be reused for this finalization.</param>
             private async Task<CompilationInfo> FinalizeCompilationAsync(
                 SolutionState solution,
                 Compilation compilationWithoutGenerators,
                 TextDocumentStates<SourceGeneratedDocumentState>? authoritativeGeneratedDocuments,
                 TextDocumentStates<SourceGeneratedDocumentState> nonAuthoritativeGeneratedDocuments,
                 Compilation? compilationWithStaleGeneratedTrees,
+                GeneratorDriver? generatorDriver,
                 CancellationToken cancellationToken)
             {
                 try
@@ -812,7 +837,7 @@ private async Task<CompilationInfo> FinalizeCompilationAsync(
                     {
                         generatedDocuments = authoritativeGeneratedDocuments.Value;
                         compilationWithGenerators = compilationWithoutGenerators.AddSyntaxTrees(
-                            await generatedDocuments.States.SelectAsArrayAsync(state => state.GetSyntaxTreeAsync(cancellationToken)).ConfigureAwait(false));
+                            await generatedDocuments.States.Values.SelectAsArrayAsync(state => state.GetSyntaxTreeAsync(cancellationToken)).ConfigureAwait(false));
                     }
                     else
                     {
@@ -820,76 +845,77 @@ private async Task<CompilationInfo> FinalizeCompilationAsync(
 
                         if (ProjectState.SourceGenerators.Any())
                         {
-                            var additionalTexts = this.ProjectState.AdditionalDocumentStates.SelectAsArray<AdditionalText>(state => new AdditionalTextWithState(state));
-                            var compilationFactory = this.ProjectState.LanguageServices.GetRequiredService<ICompilationFactoryService>();
+                            // If we don't already have a generator driver, we'll have to create one from scratch
+                            if (generatorDriver == null)
+                            {
+                                var additionalTexts = this.ProjectState.AdditionalDocumentStates.SelectAsArray(static documentState => documentState.AdditionalText);
+                                var compilationFactory = this.ProjectState.LanguageServices.GetRequiredService<ICompilationFactoryService>();
+
+                                generatorDriver = compilationFactory.CreateGeneratorDriver(
+                                        this.ProjectState.ParseOptions!,
+                                        ProjectState.SourceGenerators,
+                                        this.ProjectState.AnalyzerOptions.AnalyzerConfigOptionsProvider,
+                                        additionalTexts);
+                            }
 
-                            var generatorDriver = compilationFactory.CreateGeneratorDriver(
-                                    this.ProjectState.ParseOptions!,
-                                    ProjectState.SourceGenerators,
-                                    this.ProjectState.AnalyzerOptions.AnalyzerConfigOptionsProvider,
-                                    additionalTexts);
+                            generatorDriver = generatorDriver.RunGenerators(compilationWithoutGenerators, cancellationToken);
+                            var runResult = generatorDriver.GetRunResult();
 
-                            if (generatorDriver != null)
+                            // We may be able to reuse compilationWithStaleGeneratedTrees if the generated trees are identical. We will assign null
+                            // to compilationWithStaleGeneratedTrees if we at any point realize it can't be used. We'll first check the count of trees
+                            // if that changed then we absolutely can't reuse it. But if the counts match, we'll then see if each generated tree
+                            // content is identical to the prior generation run; if we find a match each time, then the set of the generated trees
+                            // and the prior generated trees are identical.
+                            if (compilationWithStaleGeneratedTrees != null)
                             {
-                                generatorDriver = generatorDriver.RunGenerators(compilationWithoutGenerators, cancellationToken);
-                                var runResult = generatorDriver.GetRunResult();
-
-                                // We may be able to reuse compilationWithStaleGeneratedTrees if the generated trees are identical. We will assign null
-                                // to compilationWithStaleGeneratedTrees if we at any point realize it can't be used. We'll first check the count of trees
-                                // if that changed then we absolutely can't reuse it. But if the counts match, we'll then see if each generated tree
-                                // content is identical to the prior generation run; if we find a match each time, then the set of the generated trees
-                                // and the prior generated trees are identical.
-                                if (compilationWithStaleGeneratedTrees != null)
+                                if (nonAuthoritativeGeneratedDocuments.Count != runResult.Results.Sum(r => r.GeneratedSources.Length))
                                 {
-                                    if (nonAuthoritativeGeneratedDocuments.Count != runResult.Results.Sum(r => r.GeneratedSources.Length))
-                                    {
-                                        compilationWithStaleGeneratedTrees = null;
-                                    }
+                                    compilationWithStaleGeneratedTrees = null;
                                 }
+                            }
 
-                                foreach (var generatorResult in runResult.Results)
+                            foreach (var generatorResult in runResult.Results)
+                            {
+                                foreach (var generatedSource in generatorResult.GeneratedSources)
                                 {
-                                    foreach (var generatedSource in generatorResult.GeneratedSources)
+                                    var existing = FindExistingGeneratedDocumentState(
+                                        nonAuthoritativeGeneratedDocuments,
+                                        generatorResult.Generator,
+                                        generatedSource.HintName);
+
+                                    if (existing != null)
                                     {
-                                        var existing = FindExistingGeneratedDocumentState(
-                                            nonAuthoritativeGeneratedDocuments,
-                                            generatorResult.Generator,
-                                            generatedSource.HintName);
-
-                                        if (existing != null)
-                                        {
-                                            var newDocument = existing.WithUpdatedGeneratedContent(
-                                                    generatedSource.SourceText,
-                                                    this.ProjectState.ParseOptions!);
-
-                                            generatedDocumentsBuilder.Add(newDocument);
-
-                                            if (newDocument != existing)
-                                                compilationWithStaleGeneratedTrees = null;
-                                        }
-                                        else
-                                        {
-                                            // NOTE: the use of generatedSource.SyntaxTree to fetch the path and options is OK,
-                                            // since the tree is a lazy tree and that won't trigger the parse.
-                                            var identity = SourceGeneratedDocumentIdentity.Generate(
-                                                ProjectState.Id,
-                                                generatedSource.HintName,
-                                                generatorResult.Generator,
-                                                generatedSource.SyntaxTree.FilePath);
-
-                                            generatedDocumentsBuilder.Add(
-                                                SourceGeneratedDocumentState.Create(
-                                                    identity,
-                                                    generatedSource.SourceText,
-                                                    generatedSource.SyntaxTree.Options,
-                                                    this.ProjectState.LanguageServices,
-                                                    solution.Services));
-
-                                            // The count of trees was the same, but something didn't match up. Since we're here, at least one tree
-                                            // was added, and an equal number must have been removed. Rather than trying to incrementally update
-                                            // this compilation, we'll just toss this and re-add all the trees.
+                                        var newDocument = existing.WithUpdatedGeneratedContent(
+                                                generatedSource.SourceText,
+                                                this.ProjectState.ParseOptions!);
+
+                                        generatedDocumentsBuilder.Add(newDocument);
+
+                                        if (newDocument != existing)
                                             compilationWithStaleGeneratedTrees = null;
-                                        }
+                                    }
+                                    else
+                                    {
+                                        // NOTE: the use of generatedSource.SyntaxTree to fetch the path and options is OK,
+                                        // since the tree is a lazy tree and that won't trigger the parse.
+                                        var identity = SourceGeneratedDocumentIdentity.Generate(
+                                            ProjectState.Id,
+                                            generatedSource.HintName,
+                                            generatorResult.Generator,
+                                            generatedSource.SyntaxTree.FilePath);
+
+                                        generatedDocumentsBuilder.Add(
+                                            SourceGeneratedDocumentState.Create(
+                                                identity,
+                                                generatedSource.SourceText,
+                                                generatedSource.SyntaxTree.Options,
+                                                this.ProjectState.LanguageServices,
+                                                solution.Services));
+
+                                        // The count of trees was the same, but something didn't match up. Since we're here, at least one tree
+                                        // was added, and an equal number must have been removed. Rather than trying to incrementally update
+                                        // this compilation, we'll just toss this and re-add all the trees.
+                                        compilationWithStaleGeneratedTrees = null;
                                     }
                                 }
                             }
@@ -905,7 +931,7 @@ private async Task<CompilationInfo> FinalizeCompilationAsync(
                         {
                             generatedDocuments = new TextDocumentStates<SourceGeneratedDocumentState>(generatedDocumentsBuilder.ToImmutableAndClear());
                             compilationWithGenerators = compilationWithoutGenerators.AddSyntaxTrees(
-                                await generatedDocuments.States.SelectAsArrayAsync(state => state.GetSyntaxTreeAsync(cancellationToken)).ConfigureAwait(false));
+                                await generatedDocuments.States.Values.SelectAsArrayAsync(state => state.GetSyntaxTreeAsync(cancellationToken)).ConfigureAwait(false));
                         }
                     }
 
@@ -915,6 +941,7 @@ private async Task<CompilationInfo> FinalizeCompilationAsync(
                         compilationWithoutGenerators,
                         hasSuccessfullyLoaded,
                         generatedDocuments,
+                        generatorDriver,
                         compilationWithGenerators,
                         this.ProjectState.Id,
                         metadataReferenceToProjectId);
@@ -937,7 +964,7 @@ private async Task<CompilationInfo> FinalizeCompilationAsync(
                     var generatorAssemblyName = SourceGeneratedDocumentIdentity.GetGeneratorAssemblyName(generator);
                     var generatorTypeName = SourceGeneratedDocumentIdentity.GetGeneratorTypeName(generator);
 
-                    foreach (var state in states.States)
+                    foreach (var (_, state) in states.States)
                     {
                         if (state.SourceGeneratorAssemblyName != generatorAssemblyName)
                             continue;
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
index fcd5eab374c23..a758bd488a334 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
@@ -41,6 +41,7 @@ internal partial class SolutionState
         private readonly SolutionInfo.SolutionAttributes _solutionAttributes;
         private readonly SolutionServices _solutionServices;
         private readonly ImmutableDictionary<ProjectId, ProjectState> _projectIdToProjectStateMap;
+        private readonly ImmutableHashSet<string> _remoteSupportedLanguages;
         private readonly ImmutableDictionary<string, ImmutableArray<DocumentId>> _filePathToDocumentIdsMap;
         private readonly ProjectDependencyGraph _dependencyGraph;
 
@@ -74,6 +75,7 @@ private SolutionState(
             SerializableOptionSet options,
             IReadOnlyList<AnalyzerReference> analyzerReferences,
             ImmutableDictionary<ProjectId, ProjectState> idToProjectStateMap,
+            ImmutableHashSet<string> remoteSupportedLanguages,
             ImmutableDictionary<ProjectId, ICompilationTracker> projectIdToTrackerMap,
             ImmutableDictionary<string, ImmutableArray<DocumentId>> filePathToDocumentIdsMap,
             ProjectDependencyGraph dependencyGraph,
@@ -88,6 +90,7 @@ private SolutionState(
             Options = options;
             AnalyzerReferences = analyzerReferences;
             _projectIdToProjectStateMap = idToProjectStateMap;
+            _remoteSupportedLanguages = remoteSupportedLanguages;
             _projectIdToTrackerMap = projectIdToTrackerMap;
             _filePathToDocumentIdsMap = filePathToDocumentIdsMap;
             _dependencyGraph = dependencyGraph;
@@ -119,6 +122,7 @@ public SolutionState(
                 options,
                 analyzerReferences,
                 idToProjectStateMap: ImmutableDictionary<ProjectId, ProjectState>.Empty,
+                remoteSupportedLanguages: ImmutableHashSet<string>.Empty,
                 projectIdToTrackerMap: ImmutableDictionary<ProjectId, ICompilationTracker>.Empty,
                 filePathToDocumentIdsMap: ImmutableDictionary.Create<string, ImmutableArray<DocumentId>>(StringComparer.OrdinalIgnoreCase),
                 dependencyGraph: ProjectDependencyGraph.Empty,
@@ -203,6 +207,8 @@ private void CheckInvariants()
             // project ids must be the same:
             Debug.Assert(_projectIdToProjectStateMap.Keys.SetEquals(ProjectIds));
             Debug.Assert(_projectIdToProjectStateMap.Keys.SetEquals(_dependencyGraph.ProjectIds));
+
+            Debug.Assert(_remoteSupportedLanguages.SetEquals(GetRemoteSupportedProjectLanguages(_projectIdToProjectStateMap)));
         }
 
         private SolutionState Branch(
@@ -211,6 +217,7 @@ private SolutionState Branch(
             SerializableOptionSet? options = null,
             IReadOnlyList<AnalyzerReference>? analyzerReferences = null,
             ImmutableDictionary<ProjectId, ProjectState>? idToProjectStateMap = null,
+            ImmutableHashSet<string>? remoteSupportedProjectLanguages = null,
             ImmutableDictionary<ProjectId, ICompilationTracker>? projectIdToTrackerMap = null,
             ImmutableDictionary<string, ImmutableArray<DocumentId>>? filePathToDocumentIdsMap = null,
             ProjectDependencyGraph? dependencyGraph = null,
@@ -218,10 +225,17 @@ private SolutionState Branch(
         {
             var branchId = GetBranchId();
 
+            if (idToProjectStateMap is not null)
+            {
+                Contract.ThrowIfNull(remoteSupportedProjectLanguages);
+            }
+
             solutionAttributes ??= _solutionAttributes;
             projectIds ??= ProjectIds;
             idToProjectStateMap ??= _projectIdToProjectStateMap;
-            options ??= Options.WithLanguages(GetRemoteSupportedProjectLanguages(idToProjectStateMap));
+            remoteSupportedProjectLanguages ??= _remoteSupportedLanguages;
+            Debug.Assert(remoteSupportedProjectLanguages.SetEquals(GetRemoteSupportedProjectLanguages(idToProjectStateMap)));
+            options ??= Options.WithLanguages(remoteSupportedProjectLanguages);
             analyzerReferences ??= AnalyzerReferences;
             projectIdToTrackerMap ??= _projectIdToTrackerMap;
             filePathToDocumentIdsMap ??= _filePathToDocumentIdsMap;
@@ -253,6 +267,7 @@ private SolutionState Branch(
                 options,
                 analyzerReferences,
                 idToProjectStateMap,
+                remoteSupportedProjectLanguages,
                 projectIdToTrackerMap,
                 filePathToDocumentIdsMap,
                 dependencyGraph,
@@ -281,6 +296,7 @@ private SolutionState CreatePrimarySolution(
                 Options,
                 AnalyzerReferences,
                 _projectIdToProjectStateMap,
+                _remoteSupportedLanguages,
                 _projectIdToTrackerMap,
                 _filePathToDocumentIdsMap,
                 _dependencyGraph,
@@ -354,7 +370,7 @@ public bool ContainsAnalyzerConfigDocument([NotNullWhen(returnValue: true)] Docu
         private DocumentState GetRequiredDocumentState(DocumentId documentId)
             => GetRequiredProjectState(documentId.ProjectId).DocumentStates.GetRequiredState(documentId);
 
-        private TextDocumentState GetRequiredAdditionalDocumentState(DocumentId documentId)
+        private AdditionalDocumentState GetRequiredAdditionalDocumentState(DocumentId documentId)
             => GetRequiredProjectState(documentId.ProjectId).AdditionalDocumentStates.GetRequiredState(documentId);
 
         private AnalyzerConfigDocumentState GetRequiredAnalyzerConfigDocumentState(DocumentId documentId)
@@ -461,6 +477,9 @@ private SolutionState AddProject(ProjectId projectId, ProjectState projectState)
 
             var newProjectIds = ProjectIds.ToImmutableArray().Add(projectId);
             var newStateMap = _projectIdToProjectStateMap.Add(projectId, projectState);
+            var newLanguages = RemoteSupportedLanguages.IsSupported(projectState.Language)
+                ? _remoteSupportedLanguages.Add(projectState.Language)
+                : _remoteSupportedLanguages;
 
             var newDependencyGraph = _dependencyGraph
                 .WithAdditionalProject(projectId)
@@ -490,6 +509,7 @@ private SolutionState AddProject(ProjectId projectId, ProjectState projectState)
                 solutionAttributes: newSolutionAttributes,
                 projectIds: newProjectIds,
                 idToProjectStateMap: newStateMap,
+                remoteSupportedProjectLanguages: newLanguages,
                 projectIdToTrackerMap: newTrackerMap,
                 filePathToDocumentIdsMap: newFilePathToDocumentIdsMap,
                 dependencyGraph: newDependencyGraph);
@@ -552,9 +572,9 @@ private ImmutableDictionary<string, ImmutableArray<DocumentId>> CreateFilePathTo
         }
 
         private static IEnumerable<TextDocumentState> GetDocumentStates(ProjectState projectState)
-            => projectState.DocumentStates.States
-                   .Concat(projectState.AdditionalDocumentStates.States)
-                   .Concat(projectState.AnalyzerConfigDocumentStates.States);
+            => projectState.DocumentStates.States.Values
+                   .Concat<TextDocumentState>(projectState.AdditionalDocumentStates.States.Values)
+                   .Concat(projectState.AnalyzerConfigDocumentStates.States.Values);
 
         /// <summary>
         /// Create a new solution instance without the project specified.
@@ -573,6 +593,31 @@ public SolutionState RemoveProject(ProjectId projectId)
 
             var newProjectIds = ProjectIds.ToImmutableArray().Remove(projectId);
             var newStateMap = _projectIdToProjectStateMap.Remove(projectId);
+
+            // Remote supported languages only changes if the removed project is the last project of a supported language.
+            var newLanguages = _remoteSupportedLanguages;
+            if (_projectIdToProjectStateMap.TryGetValue(projectId, out var projectState)
+                && RemoteSupportedLanguages.IsSupported(projectState.Language))
+            {
+                var stillSupportsLanguage = false;
+                foreach (var (id, state) in _projectIdToProjectStateMap)
+                {
+                    if (id == projectId)
+                        continue;
+
+                    if (state.Language == projectState.Language)
+                    {
+                        stillSupportsLanguage = true;
+                        break;
+                    }
+                }
+
+                if (!stillSupportsLanguage)
+                {
+                    newLanguages = newLanguages.Remove(projectState.Language);
+                }
+            }
+
             var newDependencyGraph = _dependencyGraph.WithProjectRemoved(projectId);
             var newTrackerMap = CreateCompilationTrackerMap(projectId, newDependencyGraph);
             var newFilePathToDocumentIdsMap = CreateFilePathToDocumentIdsMapWithRemovedDocuments(GetDocumentStates(_projectIdToProjectStateMap[projectId]));
@@ -581,6 +626,7 @@ public SolutionState RemoveProject(ProjectId projectId)
                 solutionAttributes: newSolutionAttributes,
                 projectIds: newProjectIds,
                 idToProjectStateMap: newStateMap,
+                remoteSupportedProjectLanguages: newLanguages,
                 projectIdToTrackerMap: newTrackerMap.Remove(projectId),
                 filePathToDocumentIdsMap: newFilePathToDocumentIdsMap,
                 dependencyGraph: newDependencyGraph);
@@ -759,7 +805,7 @@ public SolutionState WithProjectCompilationOptions(ProjectId projectId, Compilat
                 return this;
             }
 
-            return ForkProject(newProject, new CompilationAndGeneratorDriverTranslationAction.ProjectCompilationOptionsAction(options));
+            return ForkProject(newProject, new CompilationAndGeneratorDriverTranslationAction.ProjectCompilationOptionsAction(newProject, isAnalyzerConfigChange: false));
         }
 
         /// <summary>
@@ -784,7 +830,7 @@ public SolutionState WithProjectParseOptions(ProjectId projectId, ParseOptions o
             }
             else
             {
-                return ForkProject(newProject, new CompilationAndGeneratorDriverTranslationAction.ReplaceAllSyntaxTreesAction(newProject));
+                return ForkProject(newProject, new CompilationAndGeneratorDriverTranslationAction.ReplaceAllSyntaxTreesAction(newProject, isParseOptionChange: true));
             }
         }
 
@@ -930,7 +976,7 @@ public SolutionState WithProjectDocumentsOrder(ProjectId projectId, ImmutableLis
                 return this;
             }
 
-            return ForkProject(newProject, new CompilationAndGeneratorDriverTranslationAction.ReplaceAllSyntaxTreesAction(newProject));
+            return ForkProject(newProject, new CompilationAndGeneratorDriverTranslationAction.ReplaceAllSyntaxTreesAction(newProject, isParseOptionChange: false));
         }
 
         /// <summary>
@@ -1105,7 +1151,7 @@ private SolutionState AddDocumentsToMultipleProjects<T>(
         public SolutionState AddAdditionalDocuments(ImmutableArray<DocumentInfo> documentInfos)
         {
             return AddDocumentsToMultipleProjects(documentInfos,
-                (documentInfo, project) => new TextDocumentState(documentInfo, _solutionServices),
+                (documentInfo, project) => new AdditionalDocumentState(documentInfo, _solutionServices),
                 (projectState, documents) => (projectState.AddAdditionalDocuments(documents), new CompilationAndGeneratorDriverTranslationAction.AddAdditionalDocumentsAction(documents)));
         }
 
@@ -1117,7 +1163,7 @@ public SolutionState AddAnalyzerConfigDocuments(ImmutableArray<DocumentInfo> doc
                 (oldProject, documents) =>
                 {
                     var newProject = oldProject.AddAnalyzerConfigDocuments(documents);
-                    return (newProject, new CompilationAndGeneratorDriverTranslationAction.ProjectCompilationOptionsAction(newProject.CompilationOptions!));
+                    return (newProject, new CompilationAndGeneratorDriverTranslationAction.ProjectCompilationOptionsAction(newProject, isAnalyzerConfigChange: true));
                 });
         }
 
@@ -1128,7 +1174,7 @@ public SolutionState RemoveAnalyzerConfigDocuments(ImmutableArray<DocumentId> do
                 (oldProject, documentIds, _) =>
                 {
                     var newProject = oldProject.RemoveAnalyzerConfigDocuments(documentIds);
-                    return (newProject, new CompilationAndGeneratorDriverTranslationAction.ProjectCompilationOptionsAction(newProject.CompilationOptions!));
+                    return (newProject, new CompilationAndGeneratorDriverTranslationAction.ProjectCompilationOptionsAction(newProject, isAnalyzerConfigChange: true));
                 });
         }
 
@@ -1425,7 +1471,7 @@ private SolutionState UpdateDocumentState(DocumentState newDocument, bool textCh
                 newFilePathToDocumentIdsMap: newFilePathToDocumentIdsMap);
         }
 
-        private SolutionState UpdateAdditionalDocumentState(TextDocumentState newDocument, bool textChanged = false, bool recalculateDependentVersions = false)
+        private SolutionState UpdateAdditionalDocumentState(AdditionalDocumentState newDocument, bool textChanged = false, bool recalculateDependentVersions = false)
         {
             var oldProject = GetProjectState(newDocument.Id.ProjectId)!;
             var newProject = oldProject.UpdateAdditionalDocument(newDocument, textChanged, recalculateDependentVersions);
@@ -1449,7 +1495,7 @@ private SolutionState UpdateAnalyzerConfigDocumentState(AnalyzerConfigDocumentSt
             Debug.Assert(oldProject != newProject);
 
             return ForkProject(newProject,
-                newProject.CompilationOptions != null ? new CompilationAndGeneratorDriverTranslationAction.ProjectCompilationOptionsAction(newProject.CompilationOptions) : null);
+                newProject.CompilationOptions != null ? new CompilationAndGeneratorDriverTranslationAction.ProjectCompilationOptionsAction(newProject, isAnalyzerConfigChange: true) : null);
         }
 
         /// <summary>
@@ -1468,6 +1514,13 @@ private SolutionState ForkProject(
             var projectId = newProjectState.Id;
 
             var newStateMap = _projectIdToProjectStateMap.SetItem(projectId, newProjectState);
+
+            // Remote supported languages can only change if the project changes language. This is an unexpected edge
+            // case, so it's not optimized for incremental updates.
+            var newLanguages = !_projectIdToProjectStateMap.TryGetValue(projectId, out var projectState) || projectState.Language != newProjectState.Language
+                ? GetRemoteSupportedProjectLanguages(newStateMap)
+                : _remoteSupportedLanguages;
+
             newDependencyGraph ??= _dependencyGraph;
             var newTrackerMap = CreateCompilationTrackerMap(projectId, newDependencyGraph);
             // If we have a tracker for this project, then fork it as well (along with the
@@ -1484,6 +1537,7 @@ private SolutionState ForkProject(
 
             return this.Branch(
                 idToProjectStateMap: newStateMap,
+                remoteSupportedProjectLanguages: newLanguages,
                 projectIdToTrackerMap: newTrackerMap,
                 dependencyGraph: newDependencyGraph,
                 filePathToDocumentIdsMap: newFilePathToDocumentIdsMap ?? _filePathToDocumentIdsMap);
@@ -1671,10 +1725,12 @@ public SolutionState WithFrozenPartialCompilationIncludingSpecificDocument(Docum
                     var newTracker = tracker.FreezePartialStateWithTree(this, doc, tree, cancellationToken);
 
                     var newIdToProjectStateMap = _projectIdToProjectStateMap.SetItem(documentId.ProjectId, newTracker.ProjectState);
+                    var newLanguages = _remoteSupportedLanguages;
                     var newIdToTrackerMap = _projectIdToTrackerMap.SetItem(documentId.ProjectId, newTracker);
 
                     currentPartialSolution = this.Branch(
                         idToProjectStateMap: newIdToProjectStateMap,
+                        remoteSupportedProjectLanguages: newLanguages,
                         projectIdToTrackerMap: newIdToTrackerMap,
                         dependencyGraph: CreateDependencyGraph(ProjectIds, newIdToProjectStateMap));
 
@@ -2002,7 +2058,7 @@ internal bool ContainsTransitiveReference(ProjectId fromProjectId, ProjectId toP
             => _dependencyGraph.GetProjectsThatThisProjectTransitivelyDependsOn(fromProjectId).Contains(toProjectId);
 
         internal ImmutableHashSet<string> GetRemoteSupportedProjectLanguages()
-            => GetRemoteSupportedProjectLanguages(ProjectStates);
+            => _remoteSupportedLanguages;
 
         private static ImmutableHashSet<string> GetRemoteSupportedProjectLanguages(ImmutableDictionary<ProjectId, ProjectState> projectStates)
         {
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SourceGeneratedDocumentIdentity.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SourceGeneratedDocumentIdentity.cs
index 85bdbd828f310..72ea5f15aa772 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SourceGeneratedDocumentIdentity.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SourceGeneratedDocumentIdentity.cs
@@ -36,7 +36,7 @@ public SourceGeneratedDocumentIdentity(DocumentId documentId, string hintName, s
 
         public static string GetGeneratorTypeName(ISourceGenerator generator)
         {
-            return generator.GetType().FullName!;
+            return generator.GetGeneratorType().FullName!;
         }
 
         public static string GetGeneratorAssemblyName(ISourceGenerator generator)
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentStates.cs b/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentStates.cs
index 371f5f47389a3..b817dd9581326 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentStates.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentStates.cs
@@ -83,8 +83,8 @@ public TState GetRequiredState(DocumentId documentId)
         /// <summary>
         /// States ordered by <see cref="DocumentId"/>.
         /// </summary>
-        public IEnumerable<TState> States
-            => _map.Values;
+        public ImmutableSortedDictionary<DocumentId, TState> States
+            => _map;
 
         /// <summary>
         /// Get states ordered in compilation order.
diff --git a/src/Workspaces/CoreTest/Differencing/LongestCommonSubsequenceTests.cs b/src/Workspaces/CoreTest/Differencing/LongestCommonSubsequenceTests.cs
index 76bd073234001..08f7203c3536e 100644
--- a/src/Workspaces/CoreTest/Differencing/LongestCommonSubsequenceTests.cs
+++ b/src/Workspaces/CoreTest/Differencing/LongestCommonSubsequenceTests.cs
@@ -37,6 +37,7 @@ private static void VerifyMatchingPairs(IEnumerable<KeyValuePair<int, int>> actu
             {
                 sb.AppendFormat("[{0},{1}]", actPair.Key, actPair.Value);
             }
+
             var actualPairsStr = sb.ToString();
             Assert.Equal(expectedPairsStr, actualPairsStr);
         }
diff --git a/src/Workspaces/CoreTest/Remote/ServiceDescriptorTests.cs b/src/Workspaces/CoreTest/Remote/ServiceDescriptorTests.cs
index e963f875d7c52..74c052d76593d 100644
--- a/src/Workspaces/CoreTest/Remote/ServiceDescriptorTests.cs
+++ b/src/Workspaces/CoreTest/Remote/ServiceDescriptorTests.cs
@@ -170,7 +170,9 @@ internal void GetFeatureDisplayName(Type serviceInterface, ServiceDescriptor des
             Assert.NotNull(serviceInterface);
 
             var expectedName = descriptor32.GetFeatureDisplayName();
-            Assert.NotEmpty(expectedName);
+
+            // The service name couldn't be found. It may need to be added to RemoteWorkspacesResources.resx as FeatureName_{name}
+            Assert.False(string.IsNullOrEmpty(expectedName), $"Service name for '{serviceInterface.GetType()}' not available.");
 
             Assert.Equal(expectedName, descriptor64.GetFeatureDisplayName());
             Assert.Equal(expectedName, descriptor64ServerGC.GetFeatureDisplayName());
diff --git a/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs b/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs
index 5e515eaf59705..a268cc0ba6e43 100644
--- a/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs
+++ b/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs
@@ -7,6 +7,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
@@ -20,15 +21,25 @@ namespace Microsoft.CodeAnalysis.UnitTests
     [UseExportProvider]
     public class SolutionWithSourceGeneratorTests : TestBase
     {
+        // This is used to add on the preview language version which controls incremental generators being allowed.
+        // TODO: remove this method entirely and the calls once incremental generators are no longer preview
+        private static Project WithPreviewLanguageVersion(Project project)
+        {
+            return project.WithParseOptions(((CSharpParseOptions)project.ParseOptions!).WithLanguageVersion(LanguageVersion.Preview));
+        }
+
         [Theory]
         [CombinatorialData]
-        public async Task SourceGeneratorBasedOnAdditionalFileGeneratesSyntaxTreesOnce(
+        public async Task SourceGeneratorBasedOnAdditionalFileGeneratesSyntaxTrees(
             bool fetchCompilationBeforeAddingGenerator,
             bool useRecoverableTrees)
         {
+            // This test is just the sanity test to make sure generators work at all. There's not a special scenario being
+            // tested.
+
             using var workspace = useRecoverableTrees ? CreateWorkspaceWithRecoverableSyntaxTreesAndWeakCompilations() : CreateWorkspace();
-            var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented() { });
-            var project = AddEmptyProject(workspace.CurrentSolution)
+            var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
+            var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference);
 
             // Optionally fetch the compilation first, which validates that we handle both running the generator
@@ -54,12 +65,50 @@ public async Task SourceGeneratorBasedOnAdditionalFileGeneratesSyntaxTreesOnce(
             Assert.Same(generatedTree, await generatedDocument.GetSyntaxTreeAsync());
         }
 
+        [Fact]
+        public async Task IncrementalSourceGeneratorInvokedCorrectNumberOfTimes()
+        {
+            using var workspace = CreateWorkspace();
+            var generator = new GenerateFileForEachAdditionalFileWithContentsCommented();
+            var analyzerReference = new TestGeneratorReference(generator);
+            var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
+                .AddAnalyzerReference(analyzerReference)
+                .AddAdditionalDocument("Test.txt", "Hello, world!").Project
+                .AddAdditionalDocument("Test2.txt", "Hello, world!").Project;
+
+            var compilation = await project.GetRequiredCompilationAsync(CancellationToken.None);
+
+            Assert.Equal(2, compilation.SyntaxTrees.Count());
+            Assert.Equal(2, generator.AdditionalFilesConvertedCount);
+
+            // Change one of the additional documents, and rerun; we should only reprocess that one change, since this
+            // is an incremental generator.
+            project = project.AdditionalDocuments.First().WithAdditionalDocumentText(SourceText.From("Changed text!")).Project;
+
+            compilation = await project.GetRequiredCompilationAsync(CancellationToken.None);
+
+            Assert.Equal(2, compilation.SyntaxTrees.Count());
+
+            // We should now have converted three additional files -- the two from the original run and then the one that was changed.
+            // The other one should have been kept constant because that didn't change.
+            Assert.Equal(3, generator.AdditionalFilesConvertedCount);
+
+            // Change one of the source documents, and rerun; we should again only reprocess that one change.
+            project = project.AddDocument("Source.cs", SourceText.From("")).Project;
+
+            compilation = await project.GetRequiredCompilationAsync(CancellationToken.None);
+
+            // We have one extra syntax tree now, but it did not require any invocations of the incremental generator.
+            Assert.Equal(3, compilation.SyntaxTrees.Count());
+            Assert.Equal(3, generator.AdditionalFilesConvertedCount);
+        }
+
         [Fact]
         public async Task SourceGeneratorContentStillIncludedAfterSourceFileChange()
         {
             using var workspace = CreateWorkspace();
-            var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented() { });
-            var project = AddEmptyProject(workspace.CurrentSolution)
+            var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
+            var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
                 .AddDocument("Hello.cs", "// Source File").Project
                 .AddAdditionalDocument("Test.txt", "Hello, world!").Project;
@@ -90,8 +139,8 @@ static async Task AssertCompilationContainsOneRegularAndOneGeneratedFile(Project
         public async Task SourceGeneratorContentChangesAfterAdditionalFileChanges()
         {
             using var workspace = CreateWorkspace();
-            var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented() { });
-            var project = AddEmptyProject(workspace.CurrentSolution)
+            var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
+            var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
                 .AddAdditionalDocument("Test.txt", "Hello, world!").Project;
 
@@ -119,7 +168,7 @@ public async Task PartialCompilationsIncludeGeneratedFilesAfterFullGeneration()
         {
             using var workspace = CreateWorkspace();
             var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
-            var project = AddEmptyProject(workspace.CurrentSolution)
+            var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
                 .AddDocument("Hello.cs", "// Source File").Project
                 .AddAdditionalDocument("Test.txt", "Hello, world!").Project;
@@ -139,7 +188,7 @@ public async Task DocumentIdOfGeneratedDocumentsIsStable()
         {
             using var workspace = CreateWorkspace();
             var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
-            var projectBeforeChange = AddEmptyProject(workspace.CurrentSolution)
+            var projectBeforeChange = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
                 .AddAdditionalDocument("Test.txt", "Hello, world!").Project;
 
@@ -178,7 +227,7 @@ public async Task DocumentIdGuidInDifferentProjectsIsDifferent()
 
             static Solution AddProjectWithReference(Solution solution, TestGeneratorReference analyzerReference)
             {
-                var project = AddEmptyProject(solution);
+                var project = WithPreviewLanguageVersion(AddEmptyProject(solution));
                 project = project.AddAnalyzerReference(analyzerReference);
                 project = project.AddAdditionalDocument("Test.txt", "Hello, world!").Project;
 
@@ -191,7 +240,7 @@ public async Task CompilationsInCompilationReferencesIncludeGeneratedSourceFiles
         {
             using var workspace = CreateWorkspace();
             var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
-            var solution = AddEmptyProject(workspace.CurrentSolution)
+            var solution = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
                 .AddAdditionalDocument("Test.txt", "Hello, world!").Project.Solution;
 
@@ -207,6 +256,7 @@ public async Task CompilationsInCompilationReferencesIncludeGeneratedSourceFiles
 
             var compilationWithGenerator = await solution.GetRequiredProject(projectIdWithGenerator).GetRequiredCompilationAsync(CancellationToken.None);
 
+            Assert.NotEmpty(compilationWithGenerator.SyntaxTrees);
             Assert.Same(compilationWithGenerator, compilationReference.Compilation);
         }
 
@@ -215,7 +265,7 @@ public async Task RequestingGeneratedDocumentsTwiceGivesSameInstance()
         {
             using var workspace = CreateWorkspaceWithRecoverableSyntaxTreesAndWeakCompilations();
             var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
-            var project = AddEmptyProject(workspace.CurrentSolution)
+            var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
                 .AddAdditionalDocument("Test.txt", "Hello, world!").Project;
 
@@ -239,7 +289,7 @@ public async Task GetDocumentWithGeneratedTreeReturnsGeneratedDocument()
         {
             using var workspace = CreateWorkspace();
             var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
-            var project = AddEmptyProject(workspace.CurrentSolution)
+            var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
                 .AddAdditionalDocument("Test.txt", "Hello, world!").Project;
 
@@ -253,7 +303,7 @@ public async Task GetDocumentWithGeneratedTreeForInProgressReturnsGeneratedDocum
         {
             using var workspace = CreateWorkspace();
             var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
-            var project = AddEmptyProject(workspace.CurrentSolution)
+            var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
                 .AddDocument("RegularDocument.cs", "// Source File", filePath: "RegularDocument.cs").Project
                 .AddAdditionalDocument("Test.txt", "Hello, world!").Project;
@@ -427,7 +477,7 @@ public async Task OpenSourceGeneratedFileMatchesBufferContentsEvenIfGeneratedFil
         {
             using var workspace = CreateWorkspace();
             var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
-            var originalAdditionalFile = AddEmptyProject(workspace.CurrentSolution)
+            var originalAdditionalFile = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
                 .AddAdditionalDocument("Test.txt", SourceText.From(""));
 
diff --git a/src/Workspaces/CoreTestUtilities/GenerateFileForEachAdditionalFileWithContentsCommented.cs b/src/Workspaces/CoreTestUtilities/GenerateFileForEachAdditionalFileWithContentsCommented.cs
index c102036887979..88eee34dc57f3 100644
--- a/src/Workspaces/CoreTestUtilities/GenerateFileForEachAdditionalFileWithContentsCommented.cs
+++ b/src/Workspaces/CoreTestUtilities/GenerateFileForEachAdditionalFileWithContentsCommented.cs
@@ -4,38 +4,45 @@
 
 using System.IO;
 using System.Text;
+using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
 namespace Roslyn.Test.Utilities
 {
-    internal sealed class GenerateFileForEachAdditionalFileWithContentsCommented : ISourceGenerator
+    internal sealed class GenerateFileForEachAdditionalFileWithContentsCommented : IIncrementalGenerator
     {
-        public void Execute(GeneratorExecutionContext context)
-        {
-            foreach (var file in context.AdditionalFiles)
-            {
-                AddSourceForAdditionalFile(context, file);
-            }
-        }
+        /// <remarks>
+        /// This should only be updated with Interlocked APIs.
+        /// </remarks>
+        private int _additionalFilesConvertedCount;
 
-        public void Initialize(GeneratorInitializationContext context)
+        /// <summary>
+        /// The number of additional files we converted to a source file. This can be used to assert incrementality.
+        /// </summary>
+        public int AdditionalFilesConvertedCount => _additionalFilesConvertedCount;
+
+        public void Initialize(IncrementalGeneratorInitializationContext context)
         {
-            // TODO: context.RegisterForAdditionalFileChanges(UpdateContext);
+            context.RegisterSourceOutput(context.AdditionalTextsProvider, (context, additionalText) =>
+                context.AddSource(
+                    GetGeneratedFileName(additionalText.Path),
+                    GenerateSourceForAdditionalFile(additionalText, context.CancellationToken)));
         }
 
-        private static void AddSourceForAdditionalFile(GeneratorExecutionContext context, AdditionalText file)
+        private SourceText GenerateSourceForAdditionalFile(AdditionalText file, CancellationToken cancellationToken)
         {
+            Interlocked.Increment(ref _additionalFilesConvertedCount);
+
             // We're going to "comment" out the contents of the file when generating this
-            var sourceText = file.GetText(context.CancellationToken);
+            var sourceText = file.GetText(cancellationToken);
             Contract.ThrowIfNull(sourceText, "Failed to fetch the text of an additional file.");
 
             var changes = sourceText.Lines.SelectAsArray(l => new TextChange(new TextSpan(l.Start, length: 0), "// "));
             var generatedText = sourceText.WithChanges(changes);
 
-            // TODO: remove the generatedText.ToString() when I don't have to specify the encoding
-            context.AddSource(GetGeneratedFileName(file.Path), SourceText.From(generatedText.ToString(), encoding: Encoding.UTF8));
+            return SourceText.From(generatedText.ToString(), encoding: Encoding.UTF8);
         }
 
         private static string GetGeneratedFileName(string path) => $"{Path.GetFileNameWithoutExtension(path)}.generated";
diff --git a/src/Workspaces/CoreTestUtilities/ObjectExtensions.cs b/src/Workspaces/CoreTestUtilities/ObjectExtensions.cs
index b3c8d65a8b58c..db2efe35a5ea0 100644
--- a/src/Workspaces/CoreTestUtilities/ObjectExtensions.cs
+++ b/src/Workspaces/CoreTestUtilities/ObjectExtensions.cs
@@ -24,6 +24,7 @@ public static object GetPropertyValue(this object instance, string propertyName)
             {
                 throw new ArgumentException("Property " + propertyName + " was not found on type " + type.ToString());
             }
+
             var result = propertyInfo.GetValue(instance, null);
             return result;
         }
@@ -39,6 +40,7 @@ public static object GetFieldValue(this object instance, string fieldName)
                 {
                     break;
                 }
+
                 type = type.BaseType;
             }
 
@@ -46,6 +48,7 @@ public static object GetFieldValue(this object instance, string fieldName)
             {
                 throw new FieldAccessException("Field " + fieldName + " was not found on type " + type.ToString());
             }
+
             var result = fieldInfo.GetValue(instance);
             return result; // you can place a breakpoint here (for debugging purposes)
         }
diff --git a/src/Workspaces/CoreTestUtilities/OptionsCollection.cs b/src/Workspaces/CoreTestUtilities/OptionsCollection.cs
index deafef00f9a6b..7ba5994514480 100644
--- a/src/Workspaces/CoreTestUtilities/OptionsCollection.cs
+++ b/src/Workspaces/CoreTestUtilities/OptionsCollection.cs
@@ -49,6 +49,10 @@ public void Add<T>(PerLanguageOption2<CodeStyleOption2<T>> option, T value)
         public void Add<T>(PerLanguageOption2<CodeStyleOption2<T>> option, T value, NotificationOption2 notification)
             => _options.Add(new OptionKey2(option, _languageName), new CodeStyleOption2<T>(value, notification));
 
+        // 📝 This can be removed if/when collection initializers support AddRange.
+        public void Add(OptionsCollection options)
+            => AddRange(options);
+
         public void AddRange(OptionsCollection options)
         {
             foreach (var (key, value) in options)
diff --git a/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs b/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs
index bfba9ace063f2..0ecc2e85f7c20 100644
--- a/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs
+++ b/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs
@@ -270,6 +270,7 @@ public InProcRemoteServices(HostWorkspaceServices workspaceServices, TraceListen
                 RegisterRemoteBrokeredService(new RemoteGlobalNotificationDeliveryService.Factory());
                 RegisterRemoteBrokeredService(new RemoteCodeLensReferencesService.Factory());
                 RegisterRemoteBrokeredService(new RemoteEditAndContinueService.Factory());
+                RegisterRemoteBrokeredService(new RemoteValueTrackingService.Factory());
                 RegisterRemoteBrokeredService(new RemoteInheritanceMarginService.Factory());
             }
 
diff --git a/src/Workspaces/CoreTestUtilities/TestGeneratorReference.cs b/src/Workspaces/CoreTestUtilities/TestGeneratorReference.cs
index 301521aa7175d..fff413c2ac07c 100644
--- a/src/Workspaces/CoreTestUtilities/TestGeneratorReference.cs
+++ b/src/Workspaces/CoreTestUtilities/TestGeneratorReference.cs
@@ -33,6 +33,11 @@ public TestGeneratorReference(ISourceGenerator generator)
             _checksum = Checksum.From(checksumArray);
         }
 
+        public TestGeneratorReference(IIncrementalGenerator generator)
+            : this(generator.AsSourceGenerator())
+        {
+        }
+
         public override string? FullPath => null;
         public override object Id => this;
         public Guid Guid { get; }
diff --git a/src/Workspaces/Remote/Core/Microsoft.CodeAnalysis.Remote.Workspaces.csproj b/src/Workspaces/Remote/Core/Microsoft.CodeAnalysis.Remote.Workspaces.csproj
index 1e6a39c0aa780..7c050ecb2ab8c 100644
--- a/src/Workspaces/Remote/Core/Microsoft.CodeAnalysis.Remote.Workspaces.csproj
+++ b/src/Workspaces/Remote/Core/Microsoft.CodeAnalysis.Remote.Workspaces.csproj
@@ -43,7 +43,9 @@
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Remote.Razor.ServiceHub" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Remote.ServiceHub" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <InternalsVisibleTo Include="Roslyn.VisualStudio.DiagnosticsWindow" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.CodeLens" />
diff --git a/src/Workspaces/Remote/Core/RemoteWorkspacesResources.resx b/src/Workspaces/Remote/Core/RemoteWorkspacesResources.resx
index 1b2e8b945489a..1e8ee92ac65c7 100644
--- a/src/Workspaces/Remote/Core/RemoteWorkspacesResources.resx
+++ b/src/Workspaces/Remote/Core/RemoteWorkspacesResources.resx
@@ -201,4 +201,7 @@
   <data name="FeatureName_InheritanceMargin" xml:space="preserve">
     <value>Inheritance margin</value>
   </data>
+  <data name="FeatureName_ValueTracking" xml:space="preserve">
+    <value>Value Tracking</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Workspaces/Remote/Core/ServiceDescriptors.cs b/src/Workspaces/Remote/Core/ServiceDescriptors.cs
index b4231bbce3995..e2150408be908 100644
--- a/src/Workspaces/Remote/Core/ServiceDescriptors.cs
+++ b/src/Workspaces/Remote/Core/ServiceDescriptors.cs
@@ -26,6 +26,7 @@
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SymbolSearch;
 using Microsoft.CodeAnalysis.TodoComments;
+using Microsoft.CodeAnalysis.ValueTracking;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Remote
@@ -70,6 +71,7 @@ internal sealed class ServiceDescriptors
             (typeof(IRemoteGlobalNotificationDeliveryService), null),
             (typeof(IRemoteCodeLensReferencesService), null),
             (typeof(IRemoteEditAndContinueService), typeof(IRemoteEditAndContinueService.ICallback)),
+            (typeof(IRemoteValueTrackingService), null),
             (typeof(IRemoteInheritanceMarginService), null),
         });
 
diff --git a/src/Workspaces/Remote/Core/SolutionChecksumUpdater.cs b/src/Workspaces/Remote/Core/SolutionChecksumUpdater.cs
index 0878c25167aac..447b49f1803e2 100644
--- a/src/Workspaces/Remote/Core/SolutionChecksumUpdater.cs
+++ b/src/Workspaces/Remote/Core/SolutionChecksumUpdater.cs
@@ -4,6 +4,7 @@
 
 #nullable disable
 
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Internal.Log;
@@ -34,7 +35,7 @@ internal sealed class SolutionChecksumUpdater : GlobalOperationAwareIdleProcesso
         public SolutionChecksumUpdater(Workspace workspace, IAsynchronousOperationListenerProvider listenerProvider, CancellationToken shutdownToken)
             : base(listenerProvider.GetListener(FeatureAttribute.SolutionChecksumUpdater),
                    workspace.Services.GetService<IGlobalOperationNotificationService>(),
-                   workspace.Options.GetOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS), shutdownToken)
+                   TimeSpan.FromMilliseconds(workspace.Options.GetOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS)), shutdownToken)
         {
             _workspace = workspace;
             _textChangeQueue = new TaskQueue(Listener, TaskScheduler.Default);
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf
index bd5a5c8704996..cc1dd9eca9ed3 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf
@@ -127,6 +127,11 @@
         <target state="translated">TODO zjišťování komentářů</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">Kvůli přechodné chybě není funkce {0} momentálně k dispozici. Zkuste to prosím znovu později: {1}</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf
index fc7996507456d..cd7b97d9d77a5 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf
@@ -127,6 +127,11 @@
         <target state="translated">TODO Kommentarermittlung</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">Das Feature "{0}" ist aufgrund eines zeitweiligen Fehlers momentan nicht verfügbar. Versuchen Sie es später noch mal: "{1}"</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf
index 99b8c4416bd8a..2c50d40ad0c6a 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf
@@ -127,6 +127,11 @@
         <target state="translated">Detección de comentarios TODO</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">La característica "{0}" no está disponible debido a un error intermitente; vuelva a intentarlo más tarde: "{1}"</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf
index 115fbd2523ec4..af8b3ca60f428 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf
@@ -127,6 +127,11 @@
         <target state="translated">Détection de commentaires TODO</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">La fonctionnalité '{0}' est non disponible en raison d'une erreur intermittente. Réessayez plus tard : '{1}'</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf
index 675038078c2f8..cc4a2b5128487 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf
@@ -127,6 +127,11 @@
         <target state="translated">Individuazione dei commenti TODO</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">La funzionalità '{0}' non è attualmente disponibile a causa di un errore intermittente. Riprovare più tardi: '{1}'</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf
index 506710741c89b..412439c5fe36f 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf
@@ -127,6 +127,11 @@
         <target state="translated">TODO コメント検出</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">間欠的なエラーのため、機能 '{0}' は現在使用できません。後でもう一度お試しください: '{1}'</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf
index ef559a20f17ce..f2d7b14727ca6 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf
@@ -127,6 +127,11 @@
         <target state="translated">TODO 주석 검색</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">일시적 오류로 인해 기능 '{0}'을(를) 현재 사용할 수 없습니다. 나중에 다시 시도하세요. '{1}'</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf
index 9c6df3ce48c97..cdd5b37ce6dcc 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf
@@ -127,6 +127,11 @@
         <target state="translated">Odnajdywanie komentarzy TODO</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">Funkcja „{0}” jest obecnie niedostępna z powodu sporadycznego błędu, spróbuj ponownie później: „{1}”</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf
index 3632718305b99..9ae3be71fe172 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf
@@ -127,6 +127,11 @@
         <target state="translated">Descoberta de comentários TODO</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">O recurso '{0}' não está disponível no momento devido a um erro intermitente. Faça uma nova tentativa mais tarde: '{1}'</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf
index 14a16e0069e9b..08a0b4dc27be0 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf
@@ -127,6 +127,11 @@
         <target state="translated">Обнаружение комментариев TODO</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">Функция "{0}" сейчас недоступна из-за временной ошибки. Повторите попытку позже: "{1}".</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf
index 67ceac7e373aa..12ea5ffefb2cd 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf
@@ -127,6 +127,11 @@
         <target state="translated">TODO açıklamalarını bulma</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">'{0}' özelliği, aralıklı bir hata nedeniyle şu anda kullanılamıyor. Lütfen daha sonra yeniden deneyin: '{1}'</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf
index a5d85966661c9..2c0890a61bab4 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf
@@ -127,6 +127,11 @@
         <target state="translated">TODO 注释发现</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">功能“{0}”当前不可用，因为出现间歇性错误，请稍后重试:“{1}”</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf
index 3128d92209ca3..c52ca11f27c71 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf
@@ -127,6 +127,11 @@
         <target state="translated">TODO 註解探索</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_ValueTracking">
+        <source>Value Tracking</source>
+        <target state="new">Value Tracking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Feature_0_is_currently_unavailable_due_to_an_intermittent_error">
         <source>Feature '{0}' is currently unavailable due to an intermittent error, please try again later: '{1}'</source>
         <target state="translated">因為發生間歇性錯誤，所以 '{0}' 功能目前無法使用，請稍後再試: '{1}'</target>
diff --git a/src/Workspaces/Remote/ServiceHub/Host/ProjectCacheHostServiceFactory.cs b/src/Workspaces/Remote/ServiceHub/Host/ProjectCacheHostServiceFactory.cs
index c53e0538403c1..0d58c936114b2 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/ProjectCacheHostServiceFactory.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/ProjectCacheHostServiceFactory.cs
@@ -13,7 +13,7 @@ namespace Microsoft.CodeAnalysis.Remote
     [Shared]
     internal partial class ProjectCacheHostServiceFactory : IWorkspaceServiceFactory
     {
-        private const int ImplicitCacheTimeoutInMS = 10000;
+        private static readonly TimeSpan s_implicitCacheTimeout = TimeSpan.FromMilliseconds(10000);
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
@@ -22,6 +22,6 @@ public ProjectCacheHostServiceFactory()
         }
 
         public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
-            => new ProjectCacheService(workspaceServices.Workspace, ImplicitCacheTimeoutInMS);
+            => new ProjectCacheService(workspaceServices.Workspace, s_implicitCacheTimeout);
     }
 }
diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs
index b1e4b22cebb2a..4c9794f4a63fc 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs
@@ -242,7 +242,7 @@ await _assetProvider.GetAssetAsync<CompilationOptions>(
                 {
                     project = await UpdateDocumentsAsync(
                         project,
-                        project.State.DocumentStates.States,
+                        project.State.DocumentStates.States.Values,
                         oldProjectChecksums.Documents,
                         newProjectChecksums.Documents,
                         (solution, documents) => solution.AddDocuments(documents),
@@ -254,7 +254,7 @@ await _assetProvider.GetAssetAsync<CompilationOptions>(
                 {
                     project = await UpdateDocumentsAsync(
                         project,
-                        project.State.AdditionalDocumentStates.States,
+                        project.State.AdditionalDocumentStates.States.Values,
                         oldProjectChecksums.AdditionalDocuments,
                         newProjectChecksums.AdditionalDocuments,
                         (solution, documents) => solution.AddAdditionalDocuments(documents),
@@ -266,7 +266,7 @@ await _assetProvider.GetAssetAsync<CompilationOptions>(
                 {
                     project = await UpdateDocumentsAsync(
                         project,
-                        project.State.AnalyzerConfigDocumentStates.States,
+                        project.State.AnalyzerConfigDocumentStates.States.Values,
                         oldProjectChecksums.AnalyzerConfigDocuments,
                         newProjectChecksums.AnalyzerConfigDocuments,
                         (solution, documents) => solution.AddAnalyzerConfigDocuments(documents),
diff --git a/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj b/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj
index 5ad1f662f2edb..3be317d15396b 100644
--- a/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj
+++ b/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj
@@ -48,7 +48,9 @@
   </ItemGroup>
   <ItemGroup>
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery" Partner="UnitTesting" Key="$(UnitTestingKey)" />
+    <RestrictedInternalsVisibleTo Include="Microsoft.CodeAnalysis.UnitTesting.SourceBasedTestDiscovery.Core" Partner="UnitTesting" Key="$(UnitTestingKey)" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Workspaces.Test.Utilities" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities2" />
diff --git a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/PerformanceQueue.cs b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/PerformanceQueue.cs
index 6693cd16b0753..92b5a15249b5f 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/PerformanceQueue.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/PerformanceQueue.cs
@@ -125,8 +125,8 @@ private class Snapshot
             /// </summary>
             private readonly Dictionary<int, double> _performanceMap;
 
-            public Snapshot(IEnumerable<(string analyzerId, TimeSpan timeSpan)> snapshot, int unitCount) :
-                this(Convert(snapshot), unitCount)
+            public Snapshot(IEnumerable<(string analyzerId, TimeSpan timeSpan)> snapshot, int unitCount)
+                : this(Convert(snapshot), unitCount)
             {
             }
 
diff --git a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/PerformanceTrackerService.cs b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/PerformanceTrackerService.cs
index d6cb2cde53457..2cfbc915461e0 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/PerformanceTrackerService.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/PerformanceTrackerService.cs
@@ -44,8 +44,8 @@ internal class PerformanceTrackerService : IPerformanceTrackerService
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public PerformanceTrackerService() :
-            this(DefaultMinLOFValue, DefaultAverageThreshold, DefaultStddevThreshold)
+        public PerformanceTrackerService()
+            : this(DefaultMinLOFValue, DefaultAverageThreshold, DefaultStddevThreshold)
         {
         }
 
diff --git a/src/Workspaces/Remote/ServiceHub/Services/Host/RemoteHostService.PerformanceReporter.cs b/src/Workspaces/Remote/ServiceHub/Services/Host/RemoteHostService.PerformanceReporter.cs
index deaa218aec9c3..e6e77c694d198 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/Host/RemoteHostService.PerformanceReporter.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/Host/RemoteHostService.PerformanceReporter.cs
@@ -43,7 +43,7 @@ public PerformanceReporter(
                 : base(
                     AsynchronousOperationListenerProvider.NullListener,
                     globalOperationNotificationService,
-                    (int)reportingInterval.TotalMilliseconds,
+                    reportingInterval,
                     shutdownToken)
             {
                 _event = new SemaphoreSlim(initialCount: 0);
diff --git a/src/Workspaces/Remote/ServiceHub/Services/ValueTracking/RemoteValueTrackingService.cs b/src/Workspaces/Remote/ServiceHub/Services/ValueTracking/RemoteValueTrackingService.cs
new file mode 100644
index 0000000000000..7f3f9e86ac4a6
--- /dev/null
+++ b/src/Workspaces/Remote/ServiceHub/Services/ValueTracking/RemoteValueTrackingService.cs
@@ -0,0 +1,72 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.ValueTracking;
+
+namespace Microsoft.CodeAnalysis.Remote
+{
+    internal sealed class RemoteValueTrackingService : BrokeredServiceBase, IRemoteValueTrackingService
+    {
+        internal sealed class Factory : FactoryBase<IRemoteValueTrackingService>
+        {
+            protected override IRemoteValueTrackingService CreateService(in ServiceConstructionArguments arguments)
+                => new RemoteValueTrackingService(arguments);
+        }
+
+        public RemoteValueTrackingService(ServiceConstructionArguments arguments)
+            : base(arguments)
+        {
+        }
+
+        public ValueTask<ImmutableArray<SerializableValueTrackedItem>> TrackValueSourceAsync(PinnedSolutionInfo solutionInfo, TextSpan selection, DocumentId documentId, CancellationToken cancellationToken)
+        {
+            return RunServiceAsync(async cancellationToken =>
+            {
+                var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
+                if (solution is null)
+                {
+                    throw new InvalidOperationException();
+                }
+
+                var document = solution.GetRequiredDocument(documentId);
+
+                var progress = new ValueTrackingProgressCollector();
+                await ValueTracker.TrackValueSourceAsync(selection, document, progress, cancellationToken).ConfigureAwait(false);
+
+                var items = progress.GetItems();
+                return items.SelectAsArray(item => SerializableValueTrackedItem.Dehydrate(solution, item, cancellationToken));
+            }, cancellationToken);
+        }
+
+        public ValueTask<ImmutableArray<SerializableValueTrackedItem>> TrackValueSourceAsync(PinnedSolutionInfo solutionInfo, SerializableValueTrackedItem previousTrackedItem, CancellationToken cancellationToken)
+        {
+            return RunServiceAsync(async cancellationToken =>
+            {
+                var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
+                if (solution is null)
+                {
+                    throw new InvalidOperationException();
+                }
+
+                var previousItem = await previousTrackedItem.RehydrateAsync(solution, cancellationToken).ConfigureAwait(false);
+                if (previousItem is null)
+                {
+                    return ImmutableArray<SerializableValueTrackedItem>.Empty;
+                }
+
+                var progress = new ValueTrackingProgressCollector();
+                await ValueTracker.TrackValueSourceAsync(solution, previousItem, progress, cancellationToken).ConfigureAwait(false);
+
+                var items = progress.GetItems();
+                return items.SelectAsArray(item => SerializableValueTrackedItem.Dehydrate(solution, item, cancellationToken));
+            }, cancellationToken);
+        }
+    }
+}
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
index 2840c20a52f23..58b1de4eecbec 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
@@ -268,6 +268,12 @@ private static Option2<CodeStyleOption2<AddImportPlacement>> CreateUsingDirectiv
             "csharp_style_implicit_object_creation_when_type_is_apparent",
             "TextEditor.CSharp.Specific.ImplicitObjectCreationWhenTypeIsApparent");
 
+        internal static readonly Option2<CodeStyleOption2<bool>> PreferNullCheckOverTypeCheck = CreateOption(
+            CSharpCodeStyleOptionGroups.ExpressionLevelPreferences, nameof(PreferNullCheckOverTypeCheck),
+            defaultValue: s_trueWithSuggestionEnforcement,
+            "csharp_style_prefer_null_check_over_type_check",
+            $"TextEditor.CSharp.Specific.{nameof(PreferNullCheckOverTypeCheck)}");
+
         public static Option2<CodeStyleOption2<bool>> AllowEmbeddedStatementsOnSameLine { get; } = CreateOption(
             CSharpCodeStyleOptionGroups.NewLinePreferences, nameof(AllowEmbeddedStatementsOnSameLine),
             defaultValue: CodeStyleOptions2.TrueWithSilentEnforcement,
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/EmbeddedLanguages/VirtualChars/CSharpVirtualCharService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/EmbeddedLanguages/VirtualChars/CSharpVirtualCharService.cs
index 4921a460d7edb..bf387e4683768 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/EmbeddedLanguages/VirtualChars/CSharpVirtualCharService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/EmbeddedLanguages/VirtualChars/CSharpVirtualCharService.cs
@@ -98,6 +98,7 @@ private static VirtualCharSequence TryConvertStringToVirtualChars(
                 Debug.Fail("This should not be reachable as long as the compiler added no diagnostics.");
                 return default;
             }
+
             if (endDelimiter.Length > 0 && !tokenText.EndsWith(endDelimiter))
             {
                 Debug.Fail("This should not be reachable as long as the compiler added no diagnostics.");
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs
index 7c1df6fa80aa5..65ca1c846c9ce 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs
@@ -10,7 +10,7 @@ public static bool IsCSharp9OrAbove(this LanguageVersion languageVersion)
             => languageVersion >= LanguageVersion.CSharp9;
 
         public static bool IsCSharp10OrAbove(this LanguageVersion languageVersion)
-            => languageVersion >= LanguageVersion.Preview;
+            => languageVersion >= LanguageVersion.CSharp10;
 
         public static bool HasConstantInterpolatedStrings(this LanguageVersion languageVersion)
             => languageVersion.IsCSharp10OrAbove();
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxNodeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxNodeExtensions.cs
index b13fd14d2f076..853461ea064cf 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxNodeExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxNodeExtensions.cs
@@ -275,7 +275,7 @@ node is UsingStatementSyntax ||
                 SyntaxKind.ParenthesizedLambdaExpression => ((ParenthesizedLambdaExpressionSyntax)declaration).ParameterList,
                 SyntaxKind.LocalFunctionStatement => ((LocalFunctionStatementSyntax)declaration).ParameterList,
                 SyntaxKind.AnonymousMethodExpression => ((AnonymousMethodExpressionSyntax)declaration).ParameterList,
-                SyntaxKind.RecordDeclaration => ((RecordDeclarationSyntax)declaration).ParameterList,
+                SyntaxKind.RecordDeclaration or SyntaxKind.RecordStructDeclaration => ((RecordDeclarationSyntax)declaration).ParameterList,
                 _ => null,
             };
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpFormattingOptions2.Parsers.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpFormattingOptions2.Parsers.cs
index fa3f0322fcff4..e35b6c78bc1fd 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpFormattingOptions2.Parsers.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpFormattingOptions2.Parsers.cs
@@ -92,10 +92,12 @@ internal static bool DetermineIfNewLineOptionIsSet(string value, NewLineOption o
             {
                 return option;
             }
+
             if (s_legacyNewLineOptionsEditorConfigMap.TryGetValue(value, out var legacyOption))
             {
                 return legacyOption;
             }
+
             return null;
         }
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/FormattingHelpers.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/FormattingHelpers.cs
index 99a45e3ec9dbe..be7469abc0aee 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/FormattingHelpers.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/FormattingHelpers.cs
@@ -109,6 +109,9 @@ public static bool IsColonInTypeBaseList(this SyntaxToken token)
         public static bool IsCommaInArgumentOrParameterList(this SyntaxToken token)
             => token.Kind() == SyntaxKind.CommaToken && (token.Parent.IsAnyArgumentList() || token.Parent.IsKind(SyntaxKind.ParameterList) || token.Parent.IsKind(SyntaxKind.FunctionPointerParameterList));
 
+        public static bool IsOpenParenInParameterListOfParenthesizedLambdaExpression(this SyntaxToken token)
+            => token.Kind() == SyntaxKind.OpenParenToken && token.Parent.IsKind(SyntaxKind.ParameterList) && token.Parent.Parent.IsKind(SyntaxKind.ParenthesizedLambdaExpression);
+
         public static bool IsLambdaBodyBlock(this SyntaxNode node)
         {
             if (node.Kind() != SyntaxKind.Block)
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/NewLineUserSettingFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/NewLineUserSettingFormattingRule.cs
index 8b74c5262537e..14f0f9052e633 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/NewLineUserSettingFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/NewLineUserSettingFormattingRule.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting.Rules;
@@ -41,7 +42,7 @@ private static bool IsControlBlock(SyntaxNode node)
         {
             RoslynDebug.Assert(node != null);
 
-            if (node.Kind() == SyntaxKind.SwitchStatement)
+            if (node.IsKind(SyntaxKind.SwitchStatement))
             {
                 return true;
             }
@@ -109,7 +110,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { in the type declaration context
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && (currentToken.Parent is BaseTypeDeclarationSyntax || currentToken.Parent is NamespaceDeclarationSyntax))
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent is BaseTypeDeclarationSyntax or NamespaceDeclarationSyntax)
             {
                 if (!_options.NewLinesForBracesInTypes)
                 {
@@ -128,9 +129,7 @@ private static bool IsControlBlock(SyntaxNode node)
 
             // new { - Object Initialization, or with { - Record with initializer, or is { - property pattern clauses
             if (currentToken.IsKind(SyntaxKind.OpenBraceToken) &&
-                (currentToken.Parent.IsKind(SyntaxKind.ObjectInitializerExpression) ||
-                currentToken.Parent.IsKind(SyntaxKind.WithInitializerExpression) ||
-                currentToken.Parent.IsKind(SyntaxKind.PropertyPatternClause)))
+                currentToken.Parent.IsKind(SyntaxKind.ObjectInitializerExpression, SyntaxKind.WithInitializerExpression, SyntaxKind.PropertyPatternClause))
             {
                 if (!_options.NewLinesForBracesInObjectCollectionArrayInitializers)
                 {
@@ -141,7 +140,7 @@ private static bool IsControlBlock(SyntaxNode node)
             var currentTokenParentParent = currentToken.Parent.Parent;
 
             // * { - in the member declaration context
-            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null && currentTokenParentParent is MemberDeclarationSyntax)
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent is MemberDeclarationSyntax)
             {
                 var option = currentTokenParentParent is BasePropertyDeclarationSyntax
                     ? _options.NewLinesForBracesInProperties
@@ -153,7 +152,7 @@ private static bool IsControlBlock(SyntaxNode node)
                 }
             }
 
-            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null && currentTokenParentParent is AccessorDeclarationSyntax)
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent is AccessorDeclarationSyntax)
             {
                 if (!_options.NewLinesForBracesInAccessors)
                 {
@@ -162,7 +161,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the anonymous Method context
-            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null && currentTokenParentParent.IsKind(SyntaxKind.AnonymousMethodExpression))
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent.IsKind(SyntaxKind.AnonymousMethodExpression))
             {
                 if (!_options.NewLinesForBracesInAnonymousMethods)
                 {
@@ -171,7 +170,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the local function context
-            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null && currentTokenParentParent.IsKind(SyntaxKind.LocalFunctionStatement))
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent.IsKind(SyntaxKind.LocalFunctionStatement))
             {
                 if (!_options.NewLinesForBracesInMethods)
                 {
@@ -180,8 +179,8 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the Lambda context
-            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null &&
-               (currentTokenParentParent.IsKind(SyntaxKind.SimpleLambdaExpression) || currentTokenParentParent.IsKind(SyntaxKind.ParenthesizedLambdaExpression)))
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) &&
+               currentTokenParentParent.IsKind(SyntaxKind.SimpleLambdaExpression, SyntaxKind.ParenthesizedLambdaExpression))
             {
                 if (!_options.NewLinesForBracesInLambdaExpressionBody)
                 {
@@ -199,7 +198,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the control statement context
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && IsControlBlock(currentToken.Parent))
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && IsControlBlock(currentToken.Parent))
             {
                 if (!_options.NewLinesForBracesInControlBlocks)
                 {
@@ -219,7 +218,7 @@ private static bool IsControlBlock(SyntaxNode node)
             // else condition is actually handled in the GetAdjustSpacesOperation()
 
             // For Object Initialization Expression
-            if (previousToken.Kind() == SyntaxKind.CommaToken && previousToken.Parent.IsKind(SyntaxKind.ObjectInitializerExpression))
+            if (previousToken.IsKind(SyntaxKind.CommaToken) && previousToken.Parent.IsKind(SyntaxKind.ObjectInitializerExpression))
             {
                 if (_options.NewLineForMembersInObjectInit)
                 {
@@ -233,7 +232,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // For Anonymous Object Creation Expression
-            if (previousToken.Kind() == SyntaxKind.CommaToken && previousToken.Parent.IsKind(SyntaxKind.AnonymousObjectCreationExpression))
+            if (previousToken.IsKind(SyntaxKind.CommaToken) && previousToken.Parent.IsKind(SyntaxKind.AnonymousObjectCreationExpression))
             {
                 if (_options.NewLineForMembersInAnonymousTypes)
                 {
@@ -261,7 +260,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * catch in the try catch context
-            if (currentToken.Kind() == SyntaxKind.CatchKeyword)
+            if (currentToken.IsKind(SyntaxKind.CatchKeyword))
             {
                 if (_options.NewLineForCatch)
                 {
@@ -274,7 +273,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * Finally
-            if (currentToken.Kind() == SyntaxKind.FinallyKeyword)
+            if (currentToken.IsKind(SyntaxKind.FinallyKeyword))
             {
                 if (_options.NewLineForFinally)
                 {
@@ -287,7 +286,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the type declaration context
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && (currentToken.Parent is BaseTypeDeclarationSyntax || currentToken.Parent is NamespaceDeclarationSyntax))
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent is BaseTypeDeclarationSyntax or NamespaceDeclarationSyntax)
             {
                 if (_options.NewLinesForBracesInTypes)
                 {
@@ -300,7 +299,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // new { - Anonymous object creation
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentToken.Parent.Kind() == SyntaxKind.AnonymousObjectCreationExpression)
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent.IsKind(SyntaxKind.AnonymousObjectCreationExpression))
             {
                 if (_options.NewLinesForBracesInAnonymousTypes)
                 {
@@ -317,10 +316,7 @@ private static bool IsControlBlock(SyntaxNode node)
             // with { - Record with initializer
             // is { - property pattern clauses
             if (currentToken.IsKind(SyntaxKind.OpenBraceToken) &&
-                (currentToken.Parent.IsKind(SyntaxKind.ObjectInitializerExpression) ||
-                currentToken.Parent.IsKind(SyntaxKind.CollectionInitializerExpression) ||
-                currentToken.Parent.IsKind(SyntaxKind.WithInitializerExpression) ||
-                currentToken.Parent.IsKind(SyntaxKind.PropertyPatternClause)))
+                currentToken.Parent.IsKind(SyntaxKind.ObjectInitializerExpression, SyntaxKind.CollectionInitializerExpression, SyntaxKind.WithInitializerExpression, SyntaxKind.PropertyPatternClause))
             {
                 if (_options.NewLinesForBracesInObjectCollectionArrayInitializers)
                 {
@@ -337,8 +333,7 @@ private static bool IsControlBlock(SyntaxNode node)
             //             new[] {
             //             { - Implicit Array
             if (currentToken.IsKind(SyntaxKind.OpenBraceToken) &&
-                (currentToken.Parent.Kind() == SyntaxKind.ArrayInitializerExpression ||
-                currentToken.Parent.Kind() == SyntaxKind.ImplicitArrayCreationExpression))
+                currentToken.Parent.IsKind(SyntaxKind.ArrayInitializerExpression, SyntaxKind.ImplicitArrayCreationExpression))
             {
                 return null;
             }
@@ -346,7 +341,7 @@ private static bool IsControlBlock(SyntaxNode node)
             var currentTokenParentParent = currentToken.Parent.Parent;
 
             // * { - in the member declaration context
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null && currentTokenParentParent is MemberDeclarationSyntax)
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent is MemberDeclarationSyntax)
             {
                 var option = currentTokenParentParent is BasePropertyDeclarationSyntax
                     ? _options.NewLinesForBracesInProperties
@@ -363,7 +358,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the property accessor context
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null && currentTokenParentParent is AccessorDeclarationSyntax)
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent is AccessorDeclarationSyntax)
             {
                 if (_options.NewLinesForBracesInAccessors)
                 {
@@ -376,7 +371,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the anonymous Method context
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null && currentTokenParentParent.Kind() == SyntaxKind.AnonymousMethodExpression)
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent.IsKind(SyntaxKind.AnonymousMethodExpression))
             {
                 if (_options.NewLinesForBracesInAnonymousMethods)
                 {
@@ -389,7 +384,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the local function context
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null && currentTokenParentParent.Kind() == SyntaxKind.LocalFunctionStatement)
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent.IsKind(SyntaxKind.LocalFunctionStatement))
             {
                 if (_options.NewLinesForBracesInMethods)
                 {
@@ -402,8 +397,8 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the simple Lambda context
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null &&
-               (currentTokenParentParent.Kind() == SyntaxKind.SimpleLambdaExpression || currentTokenParentParent.Kind() == SyntaxKind.ParenthesizedLambdaExpression))
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) &&
+               currentTokenParentParent.IsKind(SyntaxKind.SimpleLambdaExpression, SyntaxKind.ParenthesizedLambdaExpression))
             {
                 if (_options.NewLinesForBracesInLambdaExpressionBody)
                 {
@@ -429,7 +424,7 @@ private static bool IsControlBlock(SyntaxNode node)
             }
 
             // * { - in the control statement context
-            if (currentToken.Kind() == SyntaxKind.OpenBraceToken && IsControlBlock(currentToken.Parent))
+            if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && IsControlBlock(currentToken.Parent))
             {
                 if (_options.NewLinesForBracesInControlBlocks)
                 {
@@ -444,7 +439,7 @@ private static bool IsControlBlock(SyntaxNode node)
             // Wrapping - Leave statements on same line (false):
             // Insert a newline between the previous statement and this one.
             // ; *
-            if (previousToken.Kind() == SyntaxKind.SemicolonToken
+            if (previousToken.IsKind(SyntaxKind.SemicolonToken)
                 && (previousToken.Parent is StatementSyntax && !previousToken.Parent.IsKind(SyntaxKind.ForStatement))
                 && !_options.WrappingKeepStatementsOnSingleLine)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs
index 374f9588901bf..c19cdf32fb0b6 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs
@@ -52,13 +52,28 @@ public override AbstractFormattingRule WithOptions(AnalyzerConfigOptions options
             // For Method Declaration
             if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.IdentifierToken)
             {
+                // Parenthesized lambda with explicit return type.
+                if (currentToken.IsOpenParenInParameterListOfParenthesizedLambdaExpression())
+                {
+                    return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
+                }
+
                 return AdjustSpacesOperationZeroOrOne(_options.SpacingAfterMethodDeclarationName);
             }
 
             // For Generic Method Declaration
-            if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.GreaterThanToken && previousParentKind == SyntaxKind.TypeParameterList)
+            if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.GreaterThanToken)
             {
-                return AdjustSpacesOperationZeroOrOne(_options.SpacingAfterMethodDeclarationName);
+                // Parenthesized lambda with explicit generic return type.
+                if (currentToken.IsOpenParenInParameterListOfParenthesizedLambdaExpression() && previousParentKind == SyntaxKind.TypeArgumentList)
+                {
+                    return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
+                }
+
+                if (previousParentKind == SyntaxKind.TypeParameterList)
+                {
+                    return AdjustSpacesOperationZeroOrOne(_options.SpacingAfterMethodDeclarationName);
+                }
             }
 
             // Case: public static implicit operator string(Program p) { return null; }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
index 11e1bd60da9c8..49c4a03e97194 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
@@ -880,6 +880,7 @@ public string GetDisplayName(SyntaxNode? node, DisplayNameOptions options, strin
                         {
                             name = "~" + name;
                         }
+
                         if ((options & DisplayNameOptions.IncludeTypeParameters) != 0)
                         {
                             var pooled = PooledStringBuilder.GetInstance();
@@ -907,6 +908,7 @@ public string GetDisplayName(SyntaxNode? node, DisplayNameOptions options, strin
                     }
                 }
             }
+
             Debug.Assert(name != null, "Unexpected node type " + node.Kind());
             return name;
         }
@@ -922,6 +924,7 @@ private static void AppendTypeParameterList(StringBuilder builder, TypeParameter
                     builder.Append(", ");
                     builder.Append(typeParameterList.Parameters[i].Identifier.ValueText);
                 }
+
                 builder.Append('>');
             }
         }
@@ -2042,6 +2045,7 @@ public override DeclarationKind GetDeclarationKind(SyntaxNode declaration)
                                 return DeclarationKind.Variable;
                             }
                         }
+
                         break;
                     }
 
@@ -2051,6 +2055,7 @@ public override DeclarationKind GetDeclarationKind(SyntaxNode declaration)
                     {
                         return DeclarationKind.Attribute;
                     }
+
                     break;
 
                 case SyntaxKind.Attribute:
@@ -2058,6 +2063,7 @@ public override DeclarationKind GetDeclarationKind(SyntaxNode declaration)
                     {
                         return DeclarationKind.Attribute;
                     }
+
                     break;
 
                 case SyntaxKind.GetAccessorDeclaration:
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
index 0e527a0c4f36f..f4ff1fa562605 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
@@ -914,6 +914,7 @@ private static ulong FindSurprisingSignExtensionBits(IOperation? operation, bool
                     case 2: return unchecked((ulong)(ushort)recursive);
                     case 4: return unchecked((ulong)(uint)recursive);
                 }
+
                 Debug.Assert(false, "How did we get here?");
                 return recursive;
             }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
index faf79cc6b0e29..ac9929602d103 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
@@ -39,6 +39,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.Singleton.Enumerator`1.cs" Link="InternalUtilities\SpecializedCollections.Singleton.Enumerator`1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs" Link="InternalUtilities\StringExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\ValueTaskFactory.cs" Link="InternalUtilities\ValueTaskFactory.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\VoidResult.cs" Link="InternalUtilities\VoidResult.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\YieldAwaitableExtensions.cs" Link="InternalUtilities\YieldAwaitableExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\Syntax\SyntaxTreeExtensions.cs" Link="Syntax\SyntaxTreeExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\Collections\ImmutableArrayExtensions.cs" Link="Collections\ImmutableArrayExtensions.cs" />
@@ -453,7 +454,6 @@
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\ValuesSources\WeaklyCachedRecoverableValueSource.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\ValuesSources\WeaklyCachedValueSource.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\ValuesSources\WeakValueSource.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Utilities\VoidResult.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\WeakEventHandler.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/INamedTypeSymbolExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/INamedTypeSymbolExtensions.cs
index 5e0c583c26b07..1eaaf5a0a9d74 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/INamedTypeSymbolExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/INamedTypeSymbolExtensions.cs
@@ -204,7 +204,8 @@ static ImmutableArray<ISymbol> GetImplicitlyImplementableMembers(INamedTypeSymbo
                 {
                     return type.GetMembers().WhereAsArray(m => m.DeclaredAccessibility == Accessibility.Public &&
                                                                m.Kind != SymbolKind.NamedType && IsImplementable(m) &&
-                                                               !IsPropertyWithNonPublicImplementableAccessor(m));
+                                                               !IsPropertyWithNonPublicImplementableAccessor(m) &&
+                                                               IsImplicitlyImplementable(m, within));
                 }
 
                 return type.GetMembers();
@@ -226,6 +227,22 @@ static bool IsNonPublicImplementableAccessor(IMethodSymbol? accessor)
             {
                 return accessor != null && IsImplementable(accessor) && accessor.DeclaredAccessibility != Accessibility.Public;
             }
+
+            static bool IsImplicitlyImplementable(ISymbol member, ISymbol within)
+            {
+                if (member is IMethodSymbol { IsStatic: true, IsAbstract: true, MethodKind: MethodKind.UserDefinedOperator } method)
+                {
+                    // For example, the following is not implementable implicitly.
+                    // interface I { static abstract int operator -(I x); }
+                    // But the following is implementable:
+                    // interface I<T> where T : I<T> { static abstract int operator -(T x); }
+
+                    // See https://github.com/dotnet/csharplang/blob/main/spec/classes.md#unary-operators.
+                    return method.Parameters.Any(p => p.Type.Equals(within, SymbolEqualityComparer.Default));
+                }
+
+                return true;
+            }
         }
 
         private static bool IsImplementable(ISymbol m)
@@ -396,7 +413,7 @@ private static ImmutableArray<ISymbol> GetUnimplementedMembers(
         {
             var q = from m in interfaceMemberGetter(interfaceType, classOrStructType)
                     where m.Kind != SymbolKind.NamedType
-                    where m.Kind != SymbolKind.Method || ((IMethodSymbol)m).MethodKind == MethodKind.Ordinary
+                    where m.Kind != SymbolKind.Method || ((IMethodSymbol)m).MethodKind is MethodKind.Ordinary or MethodKind.UserDefinedOperator
                     where m.Kind != SymbolKind.Property || ((IPropertySymbol)m).IsIndexer || ((IPropertySymbol)m).CanBeReferencedByName
                     where m.Kind != SymbolKind.Event || ((IEventSymbol)m).CanBeReferencedByName
                     where !isImplemented(classOrStructType, m, isValidImplementation, cancellationToken)
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ISymbolExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ISymbolExtensions.cs
index db8f0b67019e5..74d4c40ee1fad 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ISymbolExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ISymbolExtensions.cs
@@ -137,7 +137,9 @@ public static bool IsImplementableMember([NotNullWhen(returnValue: true)] this I
                     var methodSymbol = (IMethodSymbol)symbol;
                     if (methodSymbol.MethodKind == MethodKind.Ordinary ||
                         methodSymbol.MethodKind == MethodKind.PropertyGet ||
-                        methodSymbol.MethodKind == MethodKind.PropertySet)
+                        methodSymbol.MethodKind == MethodKind.PropertySet ||
+                        methodSymbol.MethodKind == MethodKind.UserDefinedOperator ||
+                        methodSymbol.MethodKind == MethodKind.Conversion)
                     {
                         return true;
                     }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
index 138d11391b46d..769e4ae49edb8 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
@@ -504,7 +504,8 @@ internal enum FunctionId
 
         CommandHandler_Paste_ImportsOnPaste = 470,
 
-        FindDocumentInWorkspace = 480,
+        // Superseded by LSP_FindDocumentInWorkspace
+        // obsolete: FindDocumentInWorkspace = 480,
         RegisterWorkspace = 481,
 
         LSP_RequestCounter = 482,
@@ -519,5 +520,12 @@ internal enum FunctionId
         InheritanceMargin_NavigateToTarget = 488,
 
         VS_ErrorReportingService_ShowGlobalErrorInfo = 489,
+
+        ValueTracking_Command = 490,
+        ValueTracking_TrackValueSource = 491,
+
+        InheritanceMargin_GetInheritanceMemberItems = 492,
+
+        LSP_FindDocumentInWorkspace = 493,
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/Logger.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/Logger.cs
index d9c423c7bf8ca..ab10db509a070 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/Logger.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/Logger.cs
@@ -198,8 +198,8 @@ private static int GetNextUniqueBlockId()
         /// <summary>
         /// simplest way to log a start and end pair
         /// </summary>
-        public static IDisposable LogBlock(FunctionId functionId, CancellationToken token)
-            => LogBlock(functionId, string.Empty, token);
+        public static IDisposable LogBlock(FunctionId functionId, CancellationToken token, LogLevel logLevel = LogLevel.Trace)
+            => LogBlock(functionId, string.Empty, token, logLevel);
 
         /// <summary>
         /// simplest way to log a start and end pair with a simple context message which should be very cheap to create
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFactsExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFactsExtensions.cs
index 87d43d2514f41..40322e5db8e22 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFactsExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFactsExtensions.cs
@@ -440,7 +440,7 @@ public static bool IsLockStatement(this ISyntaxFacts syntaxFacts, [NotNullWhen(t
         public static bool IsReturnStatement(this ISyntaxFacts syntaxFacts, [NotNullWhen(true)] SyntaxNode node)
             => node?.RawKind == syntaxFacts.SyntaxKinds.ReturnStatement;
 
-        public static bool IsUsingStatement(this ISyntaxFacts syntaxFacts, [NotNullWhen(true)] SyntaxNode node)
+        public static bool IsUsingStatement(this ISyntaxFacts syntaxFacts, [NotNullWhen(true)] SyntaxNode? node)
             => node?.RawKind == syntaxFacts.SyntaxKinds.UsingStatement;
 
         #endregion
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/TaskExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/TaskExtensions.cs
index c03064717b8a1..fdae49f65a1f9 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/TaskExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/TaskExtensions.cs
@@ -309,23 +309,7 @@ public static Task ContinueWithAfterDelayFromAsync(
             this Task task,
             Func<Task, Task> continuationFunction,
             CancellationToken cancellationToken,
-            int millisecondsDelay,
-            TaskContinuationOptions taskContinuationOptions,
-            TaskScheduler scheduler)
-        {
-            Contract.ThrowIfNull(continuationFunction, nameof(continuationFunction));
-
-            return task.SafeContinueWith(t =>
-                Task.Delay(millisecondsDelay, cancellationToken).SafeContinueWithFromAsync(
-                    _ => continuationFunction(t), cancellationToken, TaskContinuationOptions.None, scheduler),
-                cancellationToken, taskContinuationOptions, scheduler).Unwrap();
-        }
-
-        public static Task ContinueWithAfterDelayFromAsync(
-            this Task task,
-            Func<Task, Task> continuationFunction,
-            CancellationToken cancellationToken,
-            int millisecondsDelay,
+            TimeSpan delay,
             IExpeditableDelaySource delaySource,
             TaskContinuationOptions taskContinuationOptions,
             TaskScheduler scheduler)
@@ -333,7 +317,7 @@ public static Task ContinueWithAfterDelayFromAsync(
             Contract.ThrowIfNull(continuationFunction, nameof(continuationFunction));
 
             return task.SafeContinueWith(t =>
-                delaySource.Delay(TimeSpan.FromMilliseconds(millisecondsDelay), cancellationToken).SafeContinueWithFromAsync(
+                delaySource.Delay(delay, cancellationToken).SafeContinueWithFromAsync(
                     _ => continuationFunction(t), cancellationToken, TaskContinuationOptions.None, scheduler),
                 cancellationToken, taskContinuationOptions, scheduler).Unwrap();
         }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/DirectiveSyntaxExtensions.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/DirectiveSyntaxExtensions.vb
index 64c1818e94101..24c5b30668257 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/DirectiveSyntaxExtensions.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/DirectiveSyntaxExtensions.vb
@@ -126,6 +126,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
             If Not GetDirectiveInfo(directive, cancellationToken).ConditionalMap.TryGetValue(directive, result) Then
                 Return SpecializedCollections.EmptyReadOnlyList(Of DirectiveTriviaSyntax)()
             End If
+
             Return result
         End Function
     End Module
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SemanticModelExtensions.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SemanticModelExtensions.vb
index fb71497a16f06..334e73bb9a0dd 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SemanticModelExtensions.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SemanticModelExtensions.vb
@@ -21,6 +21,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
                     Return results.OfType(Of ITypeSymbol)().ToList()
                 End If
             End If
+
             Return SpecializedCollections.EmptyList(Of ITypeSymbol)()
         End Function
 
@@ -32,6 +33,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
             If expression IsNot Nothing Then
                 Return semanticModel.LookupName(expression, namespacesAndTypesOnly, cancellationToken)
             End If
+
             Return SpecializedCollections.EmptyList(Of ISymbol)()
         End Function
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SyntaxNodeExtensions.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SyntaxNodeExtensions.vb
index c04d8c8d15650..8ed02ef44b5dc 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SyntaxNodeExtensions.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SyntaxNodeExtensions.vb
@@ -221,6 +221,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
                 SyntaxKind.SingleLineSubLambdaExpression
                     Return True
             End Select
+
             Return False
         End Function
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SyntaxTreeExtensions.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SyntaxTreeExtensions.vb
index 11fd4c0a9c8d3..1cf4e64ea54e9 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SyntaxTreeExtensions.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Extensions/SyntaxTreeExtensions.vb
@@ -91,6 +91,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
                 If TypeOf node Is SingleLineLambdaExpressionSyntax Then Return True
                 node = node.Parent
             End While
+
             Return False
         End Function
 
@@ -134,6 +135,7 @@ recurse:
                                 Return trivia
                             End If
                         Next
+
                         For Each trivia In child.GetLeadingTrivia.Reverse
                             If (trivia.SpanStart < position) AndAlso (position <= child.FullSpan.End) Then
                                 Return trivia
@@ -142,6 +144,7 @@ recurse:
                     End If
                 End If
             Next
+
             Return Nothing
         End Function
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
index 9a6dfb6265fca..6f89d8dbd5353 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
@@ -1014,6 +1014,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
                     builder.Append(s_dotToken)
                 End If
             End While
+
             names.Free()
 
             ' name (include generic type parameters)
@@ -1080,6 +1081,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
                     End If
                 End If
             End If
+
             Debug.Assert(name IsNot Nothing, "Unexpected node type " + node.Kind().ToString())
             Return name
         End Function
@@ -1092,6 +1094,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
                     builder.Append(", ")
                     builder.Append(typeParameterList.Parameters(i).Identifier.Text)
                 Next
+
                 builder.Append(")"c)
             End If
         End Sub
@@ -1370,6 +1373,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
                     If (node.Parent.IsKind(SyntaxKind.FieldDeclaration)) Then
                         Return True
                     End If
+
                     Return False
 
                 Case SyntaxKind.NamespaceStatement,
@@ -2296,6 +2300,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
                 Case SyntaxKind.RaiseEventAccessorBlock
                     Return DeclarationKind.RaiseAccessor
             End Select
+
             Return DeclarationKind.None
         End Function
 
@@ -2304,6 +2309,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
             For i = 0 To nodes.Count - 1
                 count = count + GetDeclarationCount(nodes(i))
             Next
+
             Return count
         End Function
 
@@ -2322,6 +2328,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
                 Case SyntaxKind.ImportsStatement
                     Return DirectCast(node, ImportsStatementSyntax).ImportsClauses.Count
             End Select
+
             Return 1
         End Function
 
@@ -2336,6 +2343,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
                         Return p.ParameterList IsNot Nothing AndAlso p.ParameterList.Parameters.Count > 0 AndAlso p.Modifiers.Any(SyntaxKind.DefaultKeyword)
                     End If
             End Select
+
             Return False
         End Function
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Utilities/CastAnalyzer.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Utilities/CastAnalyzer.vb
index 451ce43657070..31939f2043a0b 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Utilities/CastAnalyzer.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Utilities/CastAnalyzer.vb
@@ -334,6 +334,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
                         If expressionToCastType.IsWidening Then
                             Return True
                         End If
+
                         If expressionToCastType.IsNarrowing AndAlso
                             Not _semanticModel.OptionStrict = OptionStrict.On Then
                             Return True
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs
index b336edcc5a997..2616a24c40e74 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs
@@ -1623,6 +1623,7 @@ private static SyntaxNode UnwrapPossibleTuple(SyntaxNode node)
                     node = node.Parent;
                     continue;
                 }
+
                 if (node.Parent.IsKind(SyntaxKind.Argument) && node.Parent.Parent.IsKind(SyntaxKind.TupleExpression))
                 {
                     node = node.Parent.Parent;
@@ -1645,6 +1646,7 @@ private static bool IsPossibleVarDeconstructionOpenParenOrComma(SyntaxToken left
                     return true;
                 }
             }
+
             return false;
         }
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/DocumentationCommentExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/DocumentationCommentExtensions.cs
index e2caec752c8e0..a075030b96b56 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/DocumentationCommentExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/DocumentationCommentExtensions.cs
@@ -16,6 +16,7 @@ public static bool IsMultilineDocComment([NotNullWhen(true)] this DocumentationC
             {
                 return false;
             }
+
             return documentationComment.ToFullString().StartsWith("/**", StringComparison.Ordinal);
         }
     }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpTypeInferenceService.TypeInferrer.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpTypeInferenceService.TypeInferrer.cs
index b72e782fead03..fd0d31a104df4 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpTypeInferenceService.TypeInferrer.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpTypeInferenceService.TypeInferrer.cs
@@ -678,6 +678,7 @@ private void DetermineTypeParameterMapping(ITypeSymbol inferredType, ITypeSymbol
                         {
                             result[returnTypeParameter] = inferredType;
                         }
+
                         return;
                     }
                 }
@@ -705,6 +706,7 @@ private void DetermineTypeParameterMapping(ITypeSymbol inferredType, ITypeSymbol
                                 DetermineTypeParameterMapping(inferredNamedType.TypeArguments[i], returnNamedType.TypeArguments[i], result);
                             }
                         }
+
                         return;
                 }
             }
@@ -831,6 +833,7 @@ private IEnumerable<TypeInferenceInfo> InferTypeInArrayType(ArrayTypeSyntax arra
                     currentTypes = currentTypes.Select(t => t.InferredType).OfType<IArrayTypeSymbol>()
                                                .SelectAsArray(a => new TypeInferenceInfo(a.ElementType));
                 }
+
                 return currentTypes;
             }
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Utilities/SyntaxKindSet.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Utilities/SyntaxKindSet.cs
index ef4cbce90fe0c..32a6059711167 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Utilities/SyntaxKindSet.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Utilities/SyntaxKindSet.cs
@@ -93,6 +93,12 @@ internal class SyntaxKindSet
             SyntaxKind.RecordDeclaration,
         };
 
+        public static readonly ISet<SyntaxKind> ClassRecordTypeDeclarations = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        {
+            SyntaxKind.ClassDeclaration,
+            SyntaxKind.RecordDeclaration,
+        };
+
         public static readonly ISet<SyntaxKind> ClassStructRecordTypeDeclarations = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
         {
             SyntaxKind.ClassDeclaration,
@@ -106,5 +112,10 @@ internal class SyntaxKindSet
             SyntaxKind.StructDeclaration,
             SyntaxKind.RecordStructDeclaration,
         };
+
+        public static readonly ISet<SyntaxKind> InterfaceOnlyTypeDeclarations = new HashSet<SyntaxKind>(SyntaxFacts.EqualityComparer)
+        {
+            SyntaxKind.InterfaceDeclaration,
+        };
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/SyntaxKindExtensions.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/SyntaxKindExtensions.vb
index fc1116077cd83..916fc163996c9 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/SyntaxKindExtensions.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/SyntaxKindExtensions.vb
@@ -20,6 +20,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
             For Each k In kinds
                 If k = kind Then Return True
             Next
+
             Return False
         End Function
 
@@ -37,6 +38,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
             For i = start To kinds.Length - 1
                 If kinds(i) = kind Then Return i
             Next
+
             Return -1
         End Function
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicTypeInferenceService.TypeInferrer.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicTypeInferenceService.TypeInferrer.vb
index b63f1d3da171a..f3cf17f4e7803 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicTypeInferenceService.TypeInferrer.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicTypeInferenceService.TypeInferrer.vb
@@ -639,6 +639,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 If expressionStatement.Expression.IsKind(SyntaxKind.InvocationExpression) Then
                     Return InferTypeInCallStatement()
                 End If
+
                 Return SpecializedCollections.EmptyEnumerable(Of TypeInferenceInfo)()
             End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/CaseCorrection/VisualBasicCaseCorrectionService.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/CaseCorrection/VisualBasicCaseCorrectionService.Rewriter.vb
index c616b6e755e9c..2b7402542b8c3 100644
--- a/src/Workspaces/VisualBasic/Portable/CaseCorrection/VisualBasicCaseCorrectionService.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/CaseCorrection/VisualBasicCaseCorrectionService.Rewriter.vb
@@ -113,6 +113,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CaseCorrection
                                         If param Is parameterSyntax Then
                                             Exit For
                                         End If
+
                                         ordinal = ordinal + 1
                                     Next
 
diff --git a/src/Workspaces/VisualBasic/Portable/Classification/SyntaxClassification/NameSyntaxClassifier.vb b/src/Workspaces/VisualBasic/Portable/Classification/SyntaxClassification/NameSyntaxClassifier.vb
index a8ab5f8f16c48..d34c54f173a17 100644
--- a/src/Workspaces/VisualBasic/Portable/Classification/SyntaxClassification/NameSyntaxClassifier.vb
+++ b/src/Workspaces/VisualBasic/Portable/Classification/SyntaxClassification/NameSyntaxClassifier.vb
@@ -79,6 +79,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Classification.Classifiers
                 If TryClassifyIdentifier(node, semanticModel, cancellationToken, classifiedSpan) Then
                     result.Add(classifiedSpan)
                 End If
+
                 Return
             End If
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/AsyncOrIteratorFunctionReturnTypeFixer.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/AsyncOrIteratorFunctionReturnTypeFixer.vb
index a9b1e2e71a174..cfbd859fec38f 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/AsyncOrIteratorFunctionReturnTypeFixer.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/AsyncOrIteratorFunctionReturnTypeFixer.vb
@@ -102,6 +102,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup
                     Return True
                 End If
             End If
+
             Return False
         End Function
 
@@ -141,6 +142,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup
                     End Select
                 End If
             End If
+
             Return False
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AddMissingTokensCodeCleanupProvider.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AddMissingTokensCodeCleanupProvider.vb
index 2ec362da2eee6..d1890270c9e77 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AddMissingTokensCodeCleanupProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AddMissingTokensCodeCleanupProvider.vb
@@ -264,6 +264,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
                                                          If n.ParameterList.HasLeadingTrivia Then
                                                              newParamList = newParamList.WithLeadingTrivia(n.ParameterList.GetLeadingTrivia)
                                                          End If
+
                                                          If n.ParameterList.HasTrailingTrivia Then
                                                              newParamList = newParamList.WithTrailingTrivia(n.ParameterList.GetTrailingTrivia)
                                                          End If
@@ -280,6 +281,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
 
                                                      Return nodeWithParams
                                                  End Function
+
                 Return AddParenthesesTransform(node, newNode, nameChecker, Function(n) n.ParameterList, transform)
             End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/RemoveUnnecessaryLineContinuationCodeCleanupProvider.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/RemoveUnnecessaryLineContinuationCodeCleanupProvider.vb
index d4586ad551c83..7394c1197d429 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/RemoveUnnecessaryLineContinuationCodeCleanupProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/RemoveUnnecessaryLineContinuationCodeCleanupProvider.vb
@@ -275,6 +275,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
                         last.Kind <> SyntaxKind.ColonTrivia Then
                         Yield t
                     End If
+
                     last = t
                 Next
             End Function
@@ -290,6 +291,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
                         If colon Then
                             Continue For
                         End If
+
                         colon = True
                     End If
 
@@ -301,6 +303,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
                         If colon Then
                             Continue For
                         End If
+
                         colon = True
                     End If
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/EventGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/EventGenerator.vb
index 1f263d3cdf181..585f7a84dc30c 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/EventGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/EventGenerator.vb
@@ -127,6 +127,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 result = result.WithEventStatement(
                     result.EventStatement.WithImplementsClause(GenerateImplementsClause(explicitInterface)))
             End If
+
             Return result
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationService.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationService.vb
index 7ab20928f3c0e..03a965eca77db 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationService.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationService.vb
@@ -604,6 +604,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Dim computeNewModifiersList As Func(Of SyntaxTokenList, SyntaxTokenList) = Function(modifiersList As SyntaxTokenList)
                                                                                            Return SyntaxFactory.TokenList(newModifiers)
                                                                                        End Function
+
             Return UpdateDeclarationModifiers(declaration, computeNewModifiersList)
         End Function
 
@@ -611,6 +612,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Dim computeNewModifiersList As Func(Of SyntaxTokenList, SyntaxTokenList) = Function(modifiersList As SyntaxTokenList)
                                                                                            Return UpdateDeclarationAccessibility(modifiersList, newAccessibility, options)
                                                                                        End Function
+
             Return UpdateDeclarationModifiers(declaration, computeNewModifiersList)
         End Function
 
@@ -656,6 +658,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Case Else
                             Return asClause
                     End Select
+
                     Return asNewClause.WithNewExpression(updatedNewExpression)
             End Select
         End Function
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb
index 7f01fc3b020c4..9d1659d957012 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb
@@ -756,7 +756,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Public Overrides Function FieldDeclaration(name As String, type As SyntaxNode, Optional accessibility As Accessibility = Nothing, Optional modifiers As DeclarationModifiers = Nothing, Optional initializer As SyntaxNode = Nothing) As SyntaxNode
             Return SyntaxFactory.FieldDeclaration(
                 attributeLists:=Nothing,
-                modifiers:=GetModifierList(accessibility, modifiers And s_fieldModifiers, DeclarationKind.Field),
+                modifiers:=GetModifierList(accessibility, modifiers And s_fieldModifiers, declaration:=Nothing, DeclarationKind.Field),
                 declarators:=SyntaxFactory.SingletonSeparatedList(VisualBasicSyntaxGeneratorInternal.VariableDeclarator(type, name.ToModifiedIdentifier, initializer)))
         End Function
 
@@ -772,7 +772,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Dim statement = SyntaxFactory.MethodStatement(
                 kind:=If(returnType Is Nothing, SyntaxKind.SubStatement, SyntaxKind.FunctionStatement),
                 attributeLists:=Nothing,
-                modifiers:=GetModifierList(accessibility, modifiers And s_methodModifiers, DeclarationKind.Method),
+                modifiers:=GetModifierList(accessibility, modifiers And s_methodModifiers, declaration:=Nothing, DeclarationKind.Method),
                 subOrFunctionKeyword:=If(returnType Is Nothing, SyntaxFactory.Token(SyntaxKind.SubKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword)),
                 identifier:=identifier.ToIdentifierToken(),
                 typeParameterList:=GetTypeParameters(typeParameters),
@@ -803,7 +803,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Dim asClause = If(returnType IsNot Nothing, SyntaxFactory.SimpleAsClause(DirectCast(returnType, TypeSyntax)), Nothing)
             Dim parameterList = GetParameterList(parameters)
             Dim operatorToken = SyntaxFactory.Token(GetTokenKind(kind))
-            Dim modifierList As SyntaxTokenList = GetModifierList(accessibility, modifiers And s_methodModifiers, DeclarationKind.Operator)
+            Dim modifierList As SyntaxTokenList = GetModifierList(accessibility, modifiers And s_methodModifiers, declaration:=Nothing, DeclarationKind.Operator)
 
             If kind = OperatorKind.ImplicitConversion OrElse kind = OperatorKind.ExplicitConversion Then
                 modifierList = modifierList.Add(SyntaxFactory.Token(
@@ -898,21 +898,23 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             If initializer IsNot Nothing Then
                 tokens = tokens.Add(SyntaxFactory.Token(SyntaxKind.OptionalKeyword))
             End If
+
             If refKind <> RefKind.None Then
                 tokens = tokens.Add(SyntaxFactory.Token(SyntaxKind.ByRefKeyword))
             End If
+
             Return tokens
         End Function
 
         Public Overrides Function GetAccessorDeclaration(Optional accessibility As Accessibility = Accessibility.NotApplicable, Optional statements As IEnumerable(Of SyntaxNode) = Nothing) As SyntaxNode
             Return SyntaxFactory.GetAccessorBlock(
-                SyntaxFactory.GetAccessorStatement().WithModifiers(GetModifierList(accessibility, DeclarationModifiers.None, DeclarationKind.Property)),
+                SyntaxFactory.GetAccessorStatement().WithModifiers(GetModifierList(accessibility, DeclarationModifiers.None, declaration:=Nothing, DeclarationKind.Property)),
                 GetStatementList(statements))
         End Function
 
         Public Overrides Function SetAccessorDeclaration(Optional accessibility As Accessibility = Accessibility.NotApplicable, Optional statements As IEnumerable(Of SyntaxNode) = Nothing) As SyntaxNode
             Return SyntaxFactory.SetAccessorBlock(
-                SyntaxFactory.SetAccessorStatement().WithModifiers(GetModifierList(accessibility, DeclarationModifiers.None, DeclarationKind.Property)),
+                SyntaxFactory.SetAccessorStatement().WithModifiers(GetModifierList(accessibility, DeclarationModifiers.None, declaration:=Nothing, DeclarationKind.Property)),
                 GetStatementList(statements))
         End Function
 
@@ -966,7 +968,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Dim asClause = SyntaxFactory.SimpleAsClause(DirectCast(type, TypeSyntax))
             Dim statement = SyntaxFactory.PropertyStatement(
                 attributeLists:=Nothing,
-                modifiers:=GetModifierList(accessibility, modifiers And s_propertyModifiers, DeclarationKind.Property),
+                modifiers:=GetModifierList(accessibility, modifiers And s_propertyModifiers, declaration:=Nothing, DeclarationKind.Property),
                 identifier:=identifier.ToIdentifierToken(),
                 parameterList:=Nothing,
                 asClause:=asClause,
@@ -1004,7 +1006,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Dim asClause = SyntaxFactory.SimpleAsClause(DirectCast(type, TypeSyntax))
             Dim statement = SyntaxFactory.PropertyStatement(
                 attributeLists:=Nothing,
-                modifiers:=GetModifierList(accessibility, modifiers And s_indexerModifiers, DeclarationKind.Indexer, isDefault:=True),
+                modifiers:=GetModifierList(accessibility, modifiers And s_indexerModifiers, declaration:=Nothing, DeclarationKind.Indexer, isDefault:=True),
                 identifier:=SyntaxFactory.Identifier("Item"),
                 parameterList:=SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters.Cast(Of ParameterSyntax))),
                 asClause:=asClause,
@@ -1177,6 +1179,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                     Return qname.Right.ToString()
                 End If
             End If
+
             Return GetName(declaration)
         End Function
 
@@ -1249,7 +1252,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
 
             Dim prop = TryCast(declaration, PropertyStatementSyntax)
             If prop IsNot Nothing Then
-                prop = prop.WithModifiers(WithIsDefault(prop.Modifiers, GetIsDefault(prop.Modifiers) And allowDefault, GetDeclarationKind(declaration)))
+                prop = prop.WithModifiers(WithIsDefault(prop.Modifiers, GetIsDefault(prop.Modifiers) And allowDefault, declaration))
 
                 Dim accessors = New List(Of AccessorBlockSyntax)
                 accessors.Add(CreateGetAccessorBlock(Nothing))
@@ -1277,7 +1280,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return isDefault
         End Function
 
-        Private Function WithIsDefault(modifierList As SyntaxTokenList, isDefault As Boolean, kind As DeclarationKind) As SyntaxTokenList
+        Private Function WithIsDefault(modifierList As SyntaxTokenList, isDefault As Boolean, declaration As SyntaxNode) As SyntaxTokenList
             Dim access As Accessibility
             Dim modifiers As DeclarationModifiers
             Dim currentIsDefault As Boolean
@@ -1285,7 +1288,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             SyntaxFacts.GetAccessibilityAndModifiers(modifierList, access, modifiers, currentIsDefault)
 
             If currentIsDefault <> isDefault Then
-                Return GetModifierList(access, modifiers, kind, isDefault)
+                Return GetModifierList(access, modifiers, declaration, GetDeclarationKind(declaration), isDefault)
             Else
                 Return modifierList
             End If
@@ -1309,7 +1312,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return SyntaxFactory.ConstructorBlock(
                 subNewStatement:=SyntaxFactory.SubNewStatement(
                     attributeLists:=Nothing,
-                    modifiers:=GetModifierList(accessibility, modifiers And s_constructorModifiers, DeclarationKind.Constructor),
+                    modifiers:=GetModifierList(accessibility, modifiers And s_constructorModifiers, declaration:=Nothing, DeclarationKind.Constructor),
                     parameterList:=If(parameters IsNot Nothing, SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters.Cast(Of ParameterSyntax)())), SyntaxFactory.ParameterList())),
                 statements:=stats)
         End Function
@@ -1331,7 +1334,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return SyntaxFactory.ClassBlock(
                 classStatement:=SyntaxFactory.ClassStatement(
                     attributeLists:=Nothing,
-                    modifiers:=GetModifierList(accessibility, modifiers And s_classModifiers, DeclarationKind.Class),
+                    modifiers:=GetModifierList(accessibility, modifiers And s_classModifiers, declaration:=Nothing, DeclarationKind.Class),
                     identifier:=name.ToIdentifierToken(),
                     typeParameterList:=GetTypeParameters(typeParameters)),
                     [inherits]:=If(baseType IsNot Nothing, SyntaxFactory.SingletonList(SyntaxFactory.InheritsStatement(DirectCast(baseType, TypeSyntax))), Nothing),
@@ -1367,7 +1370,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return SyntaxFactory.StructureBlock(
                 structureStatement:=SyntaxFactory.StructureStatement(
                     attributeLists:=Nothing,
-                    modifiers:=GetModifierList(accessibility, modifiers And s_structModifiers, DeclarationKind.Struct),
+                    modifiers:=GetModifierList(accessibility, modifiers And s_structModifiers, declaration:=Nothing, DeclarationKind.Struct),
                     identifier:=name.ToIdentifierToken(),
                     typeParameterList:=GetTypeParameters(typeParameters)),
                 [inherits]:=Nothing,
@@ -1390,7 +1393,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return SyntaxFactory.InterfaceBlock(
                 interfaceStatement:=SyntaxFactory.InterfaceStatement(
                     attributeLists:=Nothing,
-                    modifiers:=GetModifierList(accessibility, DeclarationModifiers.None, DeclarationKind.Interface),
+                    modifiers:=GetModifierList(accessibility, DeclarationModifiers.None, declaration:=Nothing, DeclarationKind.Interface),
                     identifier:=name.ToIdentifierToken(),
                     typeParameterList:=GetTypeParameters(typeParameters)),
                 [inherits]:=If(itypes IsNot Nothing, SyntaxFactory.SingletonList(SyntaxFactory.InheritsStatement(SyntaxFactory.SeparatedList(itypes))), Nothing),
@@ -1455,7 +1458,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return SyntaxFactory.EnumBlock(
                 enumStatement:=SyntaxFactory.EnumStatement(
                     attributeLists:=Nothing,
-                    modifiers:=GetModifierList(accessibility, modifiers And GetAllowedModifiers(SyntaxKind.EnumStatement), DeclarationKind.Enum),
+                    modifiers:=GetModifierList(accessibility, modifiers And GetAllowedModifiers(SyntaxKind.EnumStatement), declaration:=Nothing, DeclarationKind.Enum),
                     identifier:=name.ToIdentifierToken(),
                     underlyingType:=underlyingTypeClause),
                     members:=AsEnumMembers(members))
@@ -1507,7 +1510,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return SyntaxFactory.DelegateStatement(
                 kind:=kind,
                 attributeLists:=Nothing,
-                modifiers:=GetModifierList(accessibility, modifiers And GetAllowedModifiers(kind), DeclarationKind.Delegate),
+                modifiers:=GetModifierList(accessibility, modifiers And GetAllowedModifiers(kind), declaration:=Nothing, DeclarationKind.Delegate),
                 subOrFunctionKeyword:=If(kind = SyntaxKind.DelegateSubStatement, SyntaxFactory.Token(SyntaxKind.SubKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword)),
                 identifier:=name.ToIdentifierToken(),
                 typeParameterList:=GetTypeParameters(typeParameters),
@@ -1528,6 +1531,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             If name IsNot Nothing Then
                 Return Me.NamespaceImportDeclaration(name)
             End If
+
             Return TryCast(node, ImportsStatementSyntax)
         End Function
 
@@ -1547,6 +1551,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                                                       CType(name, NameSyntax))))
 
             End If
+
             Throw New ArgumentException("name is not a NameSyntax.", NameOf(name))
         End Function
 
@@ -1714,6 +1719,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Return asClause.Attributes
                 End Select
             End If
+
             Return Nothing
         End Function
 
@@ -1857,6 +1863,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Return declaration.Parent
                     End If
             End Select
+
             Return declaration
         End Function
 
@@ -1879,6 +1886,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Return stmt.WithImportsClauses(SyntaxFactory.SingletonSeparatedList(DirectCast(declaration, ImportsClauseSyntax)))
                     End If
             End Select
+
             Return declaration
         End Function
 
@@ -1973,6 +1981,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 Case SyntaxKind.SimpleImportsClause
                     Return DirectCast(declaration, SimpleImportsClauseSyntax).Name.ToString()
             End Select
+
             Return String.Empty
         End Function
 
@@ -2061,6 +2070,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Return asClause.Type
                     End If
             End Select
+
             Return Nothing
         End Function
 
@@ -2138,6 +2148,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Return vd.AsClause
                     End If
             End Select
+
             Return Nothing
         End Function
 
@@ -2172,6 +2183,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 Case SyntaxKind.VariableDeclarator
                     Return DirectCast(declaration, VariableDeclaratorSyntax).WithAsClause(asClause)
             End Select
+
             Return declaration
         End Function
 
@@ -2366,8 +2378,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Dim isDefault As Boolean
             SyntaxFacts.GetAccessibilityAndModifiers(tokens, acc, currentMods, isDefault)
 
-            If (currentMods <> modifiers) Then
-                Dim newTokens = GetModifierList(acc, modifiers And GetAllowedModifiers(declaration.Kind), GetDeclarationKind(declaration), isDefault)
+            If currentMods <> modifiers Then
+                Dim newTokens = GetModifierList(acc, modifiers And GetAllowedModifiers(declaration.Kind), declaration, GetDeclarationKind(declaration), isDefault)
                 Return WithModifierTokens(declaration, Merge(tokens, newTokens))
             Else
                 Return declaration
@@ -2469,7 +2481,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 Return declaration
             End If
 
-            Dim newTokens = GetModifierList(accessibility, mods, GetDeclarationKind(declaration), isDefault)
+            Dim newTokens = GetModifierList(accessibility, mods, declaration, GetDeclarationKind(declaration), isDefault)
             'GetDeclarationKind returns None for Field if the count is > 1
             'To handle multiple declarations on a field if the Accessibility is NotApplicable, we need to add the Dim
             If declaration.Kind = SyntaxKind.FieldDeclaration AndAlso accessibility = Accessibility.NotApplicable AndAlso newTokens.Count = 0 Then
@@ -2480,7 +2492,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return WithModifierTokens(declaration, Merge(tokens, newTokens))
         End Function
 
-        Private Shared Function GetModifierList(accessibility As Accessibility, modifiers As DeclarationModifiers, kind As DeclarationKind, Optional isDefault As Boolean = False) As SyntaxTokenList
+        Private Shared Function GetModifierList(accessibility As Accessibility, modifiers As DeclarationModifiers, declaration As SyntaxNode, kind As DeclarationKind, Optional isDefault As Boolean = False) As SyntaxTokenList
             Dim _list = SyntaxFactory.TokenList()
 
             ' While partial must always be last in C#, its preferred position in VB is to be first,
@@ -2511,8 +2523,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                     Throw New NotSupportedException(String.Format("Accessibility '{0}' not supported.", accessibility))
             End Select
 
+            Dim isClass = kind = DeclarationKind.Class OrElse declaration.IsKind(SyntaxKind.ClassStatement)
             If modifiers.IsAbstract Then
-                If kind = DeclarationKind.Class Then
+                If isClass Then
                     _list = _list.Add(SyntaxFactory.Token(SyntaxKind.MustInheritKeyword))
                 Else
                     _list = _list.Add(SyntaxFactory.Token(SyntaxKind.MustOverrideKeyword))
@@ -2524,7 +2537,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             End If
 
             If modifiers.IsSealed Then
-                If kind = DeclarationKind.Class Then
+                If isClass Then
                     _list = _list.Add(SyntaxFactory.Token(SyntaxKind.NotInheritableKeyword))
                 Else
                     _list = _list.Add(SyntaxFactory.Token(SyntaxKind.NotOverridableKeyword))
@@ -2790,6 +2803,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Return ev.Value
                     End If
             End Select
+
             Return Nothing
         End Function
 
@@ -2798,6 +2812,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             If es IsNot Nothing Then
                 Return es.Expression
             End If
+
             Return DirectCast(node, ExpressionSyntax)
         End Function
 
@@ -2841,6 +2856,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Return WithEqualsValue(declaration, SyntaxFactory.EqualsValue(expr))
                     End If
             End Select
+
             Return declaration
         End Function
 
@@ -2861,6 +2877,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 Case SyntaxKind.VariableDeclarator
                     Return DirectCast(declaration, VariableDeclaratorSyntax).Initializer
             End Select
+
             Return Nothing
         End Function
 
@@ -2879,6 +2896,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Return ReplaceWithTrivia(declaration, fd.Declarators(0), fd.Declarators(0).WithInitializer(ev))
                     End If
             End Select
+
             Return declaration
         End Function
 
@@ -3197,13 +3215,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                         Return eb.WithAccessors(eb.Accessors.Add(accessor))
                 End Select
             End If
+
             Return declaration
         End Function
 
         Public Overrides Function EventDeclaration(name As String, type As SyntaxNode, Optional accessibility As Accessibility = Accessibility.NotApplicable, Optional modifiers As DeclarationModifiers = Nothing) As SyntaxNode
             Return SyntaxFactory.EventStatement(
                 attributeLists:=Nothing,
-                modifiers:=GetModifierList(accessibility, modifiers And GetAllowedModifiers(SyntaxKind.EventStatement), DeclarationKind.Event),
+                modifiers:=GetModifierList(accessibility, modifiers And GetAllowedModifiers(SyntaxKind.EventStatement), declaration:=Nothing, DeclarationKind.Event),
                 customKeyword:=Nothing,
                 eventKeyword:=SyntaxFactory.Token(SyntaxKind.EventKeyword),
                 identifier:=name.ToIdentifierToken(),
@@ -3243,9 +3262,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 If addAccessorStatements Is Nothing Then
                     addAccessorStatements = SpecializedCollections.EmptyEnumerable(Of SyntaxNode)()
                 End If
+
                 If removeAccessorStatements Is Nothing Then
                     removeAccessorStatements = SpecializedCollections.EmptyEnumerable(Of SyntaxNode)()
                 End If
+
                 If raiseAccessorStatements Is Nothing Then
                     raiseAccessorStatements = SpecializedCollections.EmptyEnumerable(Of SyntaxNode)()
                 End If
@@ -3257,7 +3278,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
 
             Dim evStatement = SyntaxFactory.EventStatement(
                 attributeLists:=Nothing,
-                modifiers:=GetModifierList(accessibility, modifiers And GetAllowedModifiers(SyntaxKind.EventStatement), DeclarationKind.Event),
+                modifiers:=GetModifierList(accessibility, modifiers And GetAllowedModifiers(SyntaxKind.EventStatement), declaration:=Nothing, DeclarationKind.Event),
                 customKeyword:=SyntaxFactory.Token(SyntaxKind.CustomKeyword),
                 eventKeyword:=SyntaxFactory.Token(SyntaxKind.EventKeyword),
                 identifier:=name.ToIdentifierToken(),
@@ -3307,6 +3328,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 Case SyntaxKind.Attribute
                     Return DirectCast(declaration, AttributeSyntax).ArgumentList
             End Select
+
             Return Nothing
         End Function
 
@@ -3320,6 +3342,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 Case SyntaxKind.Attribute
                     Return DirectCast(declaration, AttributeSyntax).WithArgumentList(argumentList)
             End Select
+
             Return declaration
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/FindSymbols/VisualBasicDeclaredSymbolInfoFactoryService.vb b/src/Workspaces/VisualBasic/Portable/FindSymbols/VisualBasicDeclaredSymbolInfoFactoryService.vb
index 08d4b155a0393..bede58f987611 100644
--- a/src/Workspaces/VisualBasic/Portable/FindSymbols/VisualBasicDeclaredSymbolInfoFactoryService.vb
+++ b/src/Workspaces/VisualBasic/Portable/FindSymbols/VisualBasicDeclaredSymbolInfoFactoryService.vb
@@ -5,6 +5,7 @@
 Imports System.Collections.Immutable
 Imports System.Composition
 Imports System.Text
+Imports System.Threading
 Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.FindSymbols
 Imports Microsoft.CodeAnalysis.Host.Mef
@@ -16,7 +17,13 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
     <ExportLanguageService(GetType(IDeclaredSymbolInfoFactoryService), LanguageNames.VisualBasic), [Shared]>
     Friend Class VisualBasicDeclaredSymbolInfoFactoryService
-        Inherits AbstractDeclaredSymbolInfoFactoryService
+        Inherits AbstractDeclaredSymbolInfoFactoryService(Of
+            CompilationUnitSyntax,
+            ImportsStatementSyntax,
+            NamespaceBlockSyntax,
+            TypeBlockSyntax,
+            EnumBlockSyntax,
+            StatementSyntax)
 
         Private Const ExtensionName As String = "Extension"
         Private Const ExtensionAttributeName As String = "ExtensionAttribute"
@@ -108,15 +115,25 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
             Return simpleName.Identifier.ValueText
         End Function
 
-        Private Shared Function GetContainerDisplayName(node As SyntaxNode) As String
+        Protected Overrides Function GetContainerDisplayName(node As StatementSyntax) As String
             Return VisualBasicSyntaxFacts.Instance.GetDisplayName(node, DisplayNameOptions.IncludeTypeParameters)
         End Function
 
-        Private Shared Function GetFullyQualifiedContainerName(node As SyntaxNode, rootNamespace As String) As String
+        Protected Overrides Function GetFullyQualifiedContainerName(node As StatementSyntax, rootNamespace As String) As String
             Return VisualBasicSyntaxFacts.Instance.GetDisplayName(node, DisplayNameOptions.IncludeNamespaces, rootNamespace)
         End Function
 
-        Public Overrides Function TryGetDeclaredSymbolInfo(stringTable As StringTable, node As SyntaxNode, rootNamespace As String, ByRef declaredSymbolInfo As DeclaredSymbolInfo) As Boolean
+        Protected Overrides Sub AddDeclaredSymbolInfosWorker(
+                container As SyntaxNode,
+                node As StatementSyntax,
+                stringTable As StringTable,
+                declaredSymbolInfos As ArrayBuilder(Of DeclaredSymbolInfo),
+                aliases As Dictionary(Of String, String),
+                extensionMethodInfo As Dictionary(Of String, ArrayBuilder(Of Integer)),
+                containerDisplayName As String,
+                fullyQualifiedContainerName As String,
+                cancellationToken As CancellationToken)
+
             ' If this Is a part of partial type that only contains nested types, then we don't make an info type for it.
             ' That's because we effectively think of this as just being a virtual container just to hold the nested
             ' types, And Not something someone would want to explicitly navigate to itself.  Similar to how we think of
@@ -127,171 +144,199 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
                typeDecl.Members.Any() AndAlso
                typeDecl.Members.All(Function(m) TypeOf m Is TypeBlockSyntax) Then
 
-                declaredSymbolInfo = Nothing
-                Return False
+                Return
+            End If
+
+            If node.Kind() = SyntaxKind.PropertyBlock Then
+                node = DirectCast(node, PropertyBlockSyntax).PropertyStatement
+            ElseIf node.Kind() = SyntaxKind.EventBlock Then
+                node = DirectCast(node, EventBlockSyntax).EventStatement
+            ElseIf TypeOf node Is MethodBlockBaseSyntax Then
+                node = DirectCast(node, MethodBlockBaseSyntax).BlockStatement
             End If
 
             Dim kind = node.Kind()
             Select Case kind
                 Case SyntaxKind.ClassBlock, SyntaxKind.InterfaceBlock, SyntaxKind.ModuleBlock, SyntaxKind.StructureBlock
                     Dim typeBlock = CType(node, TypeBlockSyntax)
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         typeDecl.BlockStatement.Identifier.ValueText,
                         GetTypeParameterSuffix(typeBlock.BlockStatement.TypeParameterList),
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent, rootNamespace),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         typeBlock.BlockStatement.Modifiers.Any(SyntaxKind.PartialKeyword),
                         If(kind = SyntaxKind.ClassBlock, DeclaredSymbolInfoKind.Class,
                         If(kind = SyntaxKind.InterfaceBlock, DeclaredSymbolInfoKind.Interface,
                         If(kind = SyntaxKind.ModuleBlock, DeclaredSymbolInfoKind.Module,
                         DeclaredSymbolInfoKind.Struct))),
-                        GetAccessibility(typeBlock, typeBlock.BlockStatement.Modifiers),
+                        GetAccessibility(container, typeBlock, typeBlock.BlockStatement.Modifiers),
                         typeBlock.BlockStatement.Identifier.Span,
                         GetInheritanceNames(stringTable, typeBlock),
-                        IsNestedType(typeBlock))
-                    Return True
+                        IsNestedType(typeBlock)))
+                    Return
                 Case SyntaxKind.EnumBlock
-                    Dim enumDecl = CType(node, EnumBlockSyntax)
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    Dim enumDecl = DirectCast(node, EnumBlockSyntax)
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         enumDecl.EnumStatement.Identifier.ValueText, Nothing,
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent, rootNamespace),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         enumDecl.EnumStatement.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Enum,
-                        GetAccessibility(enumDecl, enumDecl.EnumStatement.Modifiers),
+                        GetAccessibility(container, enumDecl, enumDecl.EnumStatement.Modifiers),
                         enumDecl.EnumStatement.Identifier.Span,
                         ImmutableArray(Of String).Empty,
-                        IsNestedType(enumDecl))
-                    Return True
-                Case SyntaxKind.ConstructorBlock
-                    Dim constructor = CType(node, ConstructorBlockSyntax)
-                    Dim typeBlock = TryCast(constructor.Parent, TypeBlockSyntax)
+                        IsNestedType(enumDecl)))
+                    Return
+                Case SyntaxKind.SubNewStatement
+                    Dim constructor = DirectCast(node, SubNewStatementSyntax)
+                    Dim typeBlock = TryCast(container, TypeBlockSyntax)
                     If typeBlock IsNot Nothing Then
-                        declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                        declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                             stringTable,
                             typeBlock.BlockStatement.Identifier.ValueText,
                             GetConstructorSuffix(constructor),
-                            GetContainerDisplayName(node.Parent),
-                            GetFullyQualifiedContainerName(node.Parent, rootNamespace),
-                            constructor.SubNewStatement.Modifiers.Any(SyntaxKind.PartialKeyword),
+                            containerDisplayName,
+                            fullyQualifiedContainerName,
+                            constructor.Modifiers.Any(SyntaxKind.PartialKeyword),
                             DeclaredSymbolInfoKind.Constructor,
-                            GetAccessibility(constructor, constructor.SubNewStatement.Modifiers),
-                            constructor.SubNewStatement.NewKeyword.Span,
+                            GetAccessibility(container, constructor, constructor.Modifiers),
+                            constructor.NewKeyword.Span,
                             ImmutableArray(Of String).Empty,
-                            parameterCount:=If(constructor.SubNewStatement.ParameterList?.Parameters.Count, 0))
+                            parameterCount:=If(constructor.ParameterList?.Parameters.Count, 0)))
 
-                        Return True
+                        Return
                     End If
                 Case SyntaxKind.DelegateFunctionStatement, SyntaxKind.DelegateSubStatement
-                    Dim delegateDecl = CType(node, DelegateStatementSyntax)
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    Dim delegateDecl = DirectCast(node, DelegateStatementSyntax)
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         delegateDecl.Identifier.ValueText,
                         GetTypeParameterSuffix(delegateDecl.TypeParameterList),
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent, rootNamespace),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         delegateDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Delegate,
-                        GetAccessibility(delegateDecl, delegateDecl.Modifiers),
+                        GetAccessibility(container, delegateDecl, delegateDecl.Modifiers),
                         delegateDecl.Identifier.Span,
-                        ImmutableArray(Of String).Empty)
-                    Return True
+                        ImmutableArray(Of String).Empty))
+                    Return
                 Case SyntaxKind.EnumMemberDeclaration
-                    Dim enumMember = CType(node, EnumMemberDeclarationSyntax)
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    Dim enumMember = DirectCast(node, EnumMemberDeclarationSyntax)
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         enumMember.Identifier.ValueText, Nothing,
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent, rootNamespace),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         isPartial:=False,
                         DeclaredSymbolInfoKind.EnumMember,
                         Accessibility.Public,
                         enumMember.Identifier.Span,
-                        ImmutableArray(Of String).Empty)
-                    Return True
+                        ImmutableArray(Of String).Empty))
+                    Return
                 Case SyntaxKind.EventStatement
-                    Dim eventDecl = CType(node, EventStatementSyntax)
-                    Dim statementOrBlock = If(TypeOf node.Parent Is EventBlockSyntax, node.Parent, node)
-                    Dim eventParent = statementOrBlock.Parent
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    Dim eventDecl = DirectCast(node, EventStatementSyntax)
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         eventDecl.Identifier.ValueText, Nothing,
-                        GetContainerDisplayName(eventParent),
-                        GetFullyQualifiedContainerName(eventParent, rootNamespace),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         eventDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Event,
-                        GetAccessibility(statementOrBlock, eventDecl.Modifiers),
+                        GetAccessibility(container, eventDecl, eventDecl.Modifiers),
                         eventDecl.Identifier.Span,
-                        ImmutableArray(Of String).Empty)
-                    Return True
-                Case SyntaxKind.FunctionBlock, SyntaxKind.SubBlock
-                    Dim funcDecl = CType(node, MethodBlockSyntax)
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                        ImmutableArray(Of String).Empty))
+                    Return
+                Case SyntaxKind.FunctionStatement, SyntaxKind.SubStatement
+                    Dim funcDecl = DirectCast(node, MethodStatementSyntax)
+                    Dim isExtension = IsExtensionMethod(funcDecl)
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
-                        funcDecl.SubOrFunctionStatement.Identifier.ValueText,
+                        funcDecl.Identifier.ValueText,
                         GetMethodSuffix(funcDecl),
-                        GetContainerDisplayName(node.Parent),
-                        GetFullyQualifiedContainerName(node.Parent, rootNamespace),
-                        funcDecl.SubOrFunctionStatement.Modifiers.Any(SyntaxKind.PartialKeyword),
-                        If(IsExtensionMethod(funcDecl), DeclaredSymbolInfoKind.ExtensionMethod, DeclaredSymbolInfoKind.Method),
-                        GetAccessibility(node, funcDecl.SubOrFunctionStatement.Modifiers),
-                        funcDecl.SubOrFunctionStatement.Identifier.Span,
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
+                        funcDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
+                        If(isExtension, DeclaredSymbolInfoKind.ExtensionMethod, DeclaredSymbolInfoKind.Method),
+                        GetAccessibility(container, funcDecl, funcDecl.Modifiers),
+                        funcDecl.Identifier.Span,
                         ImmutableArray(Of String).Empty,
-                        parameterCount:=If(funcDecl.SubOrFunctionStatement.ParameterList?.Parameters.Count, 0),
-                        typeParameterCount:=If(funcDecl.SubOrFunctionStatement.TypeParameterList?.Parameters.Count, 0))
-                    Return True
-                Case SyntaxKind.ModifiedIdentifier
-                    Dim modifiedIdentifier = CType(node, ModifiedIdentifierSyntax)
-                    Dim variableDeclarator = TryCast(modifiedIdentifier.Parent, VariableDeclaratorSyntax)
-                    Dim fieldDecl = TryCast(variableDeclarator?.Parent, FieldDeclarationSyntax)
-                    If fieldDecl IsNot Nothing Then
-                        declaredSymbolInfo = DeclaredSymbolInfo.Create(
-                            stringTable,
-                            modifiedIdentifier.Identifier.ValueText, Nothing,
-                            GetContainerDisplayName(fieldDecl.Parent),
-                            GetFullyQualifiedContainerName(fieldDecl.Parent, rootNamespace),
-                            fieldDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
-                            If(fieldDecl.Modifiers.Any(Function(m) m.Kind() = SyntaxKind.ConstKeyword),
-                                DeclaredSymbolInfoKind.Constant,
-                                DeclaredSymbolInfoKind.Field),
-                            GetAccessibility(fieldDecl, fieldDecl.Modifiers),
-                            modifiedIdentifier.Identifier.Span,
-                            ImmutableArray(Of String).Empty)
-                        Return True
+                        parameterCount:=If(funcDecl.ParameterList?.Parameters.Count, 0),
+                        typeParameterCount:=If(funcDecl.TypeParameterList?.Parameters.Count, 0)))
+                    If isExtension Then
+                        AddExtensionMethodInfo(funcDecl, aliases, declaredSymbolInfos.Count - 1, extensionMethodInfo)
                     End If
+
+                    Return
                 Case SyntaxKind.PropertyStatement
-                    Dim propertyDecl = CType(node, PropertyStatementSyntax)
-                    Dim statementOrBlock = If(TypeOf node.Parent Is PropertyBlockSyntax, node.Parent, node)
-                    Dim propertyParent = statementOrBlock.Parent
-                    declaredSymbolInfo = DeclaredSymbolInfo.Create(
+                    Dim propertyDecl = DirectCast(node, PropertyStatementSyntax)
+                    declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
                         stringTable,
                         propertyDecl.Identifier.ValueText,
                         GetPropertySuffix(propertyDecl),
-                        GetContainerDisplayName(propertyParent),
-                        GetFullyQualifiedContainerName(propertyParent, rootNamespace),
+                        containerDisplayName,
+                        fullyQualifiedContainerName,
                         propertyDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
                         DeclaredSymbolInfoKind.Property,
-                        GetAccessibility(statementOrBlock, propertyDecl.Modifiers),
+                        GetAccessibility(container, propertyDecl, propertyDecl.Modifiers),
                         propertyDecl.Identifier.Span,
-                        ImmutableArray(Of String).Empty)
-                    Return True
+                        ImmutableArray(Of String).Empty))
+                    Return
+                Case SyntaxKind.FieldDeclaration
+                    Dim fieldDecl = DirectCast(node, FieldDeclarationSyntax)
+                    For Each variableDeclarator In fieldDecl.Declarators
+                        For Each modifiedIdentifier In variableDeclarator.Names
+                            declaredSymbolInfos.Add(DeclaredSymbolInfo.Create(
+                                stringTable,
+                                modifiedIdentifier.Identifier.ValueText, Nothing,
+                                containerDisplayName,
+                                fullyQualifiedContainerName,
+                                fieldDecl.Modifiers.Any(SyntaxKind.PartialKeyword),
+                                If(fieldDecl.Modifiers.Any(Function(m) m.Kind() = SyntaxKind.ConstKeyword),
+                                    DeclaredSymbolInfoKind.Constant,
+                                    DeclaredSymbolInfoKind.Field),
+                                GetAccessibility(container, fieldDecl, fieldDecl.Modifiers),
+                                modifiedIdentifier.Identifier.Span,
+                                ImmutableArray(Of String).Empty))
+                        Next
+                    Next
             End Select
+        End Sub
 
-            declaredSymbolInfo = Nothing
-            Return False
+        Protected Overrides Function GetChildren(node As CompilationUnitSyntax) As SyntaxList(Of StatementSyntax)
+            Return node.Members
+        End Function
+
+        Protected Overrides Function GetChildren(node As NamespaceBlockSyntax) As SyntaxList(Of StatementSyntax)
+            Return node.Members
         End Function
 
-        Private Shared Function IsExtensionMethod(node As MethodBlockSyntax) As Boolean
-            Dim parameterCount = node.SubOrFunctionStatement.ParameterList?.Parameters.Count
+        Protected Overrides Function GetChildren(node As TypeBlockSyntax) As SyntaxList(Of StatementSyntax)
+            Return node.Members
+        End Function
+
+        Protected Overrides Function GetChildren(node As EnumBlockSyntax) As IEnumerable(Of StatementSyntax)
+            Return node.Members
+        End Function
+
+        Protected Overrides Function GetUsingAliases(node As CompilationUnitSyntax) As SyntaxList(Of ImportsStatementSyntax)
+            Return node.Imports
+        End Function
+
+        Protected Overrides Function GetUsingAliases(node As NamespaceBlockSyntax) As SyntaxList(Of ImportsStatementSyntax)
+            Return Nothing
+        End Function
+
+        Private Shared Function IsExtensionMethod(node As MethodStatementSyntax) As Boolean
+            Dim parameterCount = node.ParameterList?.Parameters.Count
 
             ' Extension method must have at least one parameter and declared inside a module
-            If Not parameterCount.HasValue OrElse parameterCount.Value = 0 OrElse TypeOf node.Parent IsNot ModuleBlockSyntax Then
+            If Not parameterCount.HasValue OrElse parameterCount.Value = 0 OrElse TypeOf node.Parent?.Parent IsNot ModuleBlockSyntax Then
                 Return False
             End If
 
-            For Each attributeList In node.BlockStatement.AttributeLists
+            For Each attributeList In node.AttributeLists
                 For Each attribute In attributeList.Attributes
                     ' ExtensionAttribute takes no argument.
                     If attribute.ArgumentList?.Arguments.Count > 0 Then
@@ -312,7 +357,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
             Return TypeOf node.Parent Is TypeBlockSyntax
         End Function
 
-        Private Shared Function GetAccessibility(node As SyntaxNode, modifiers As SyntaxTokenList) As Accessibility
+        Private Shared Function GetAccessibility(container As SyntaxNode, node As StatementSyntax, modifiers As SyntaxTokenList) As Accessibility
             Dim sawFriend = False
 
             For Each modifier In modifiers
@@ -331,7 +376,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
             End If
 
             ' No accessibility modifiers
-            Select Case node.Parent.Kind()
+            Select Case container.Kind()
                 Case SyntaxKind.ClassBlock
                     ' In a class, fields and shared-constructors are private by default,
                     ' everything Else Is Public
@@ -339,13 +384,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
                         Return Accessibility.Private
                     End If
 
-                    If node.Kind() = SyntaxKind.ConstructorBlock AndAlso
-                       DirectCast(node, ConstructorBlockSyntax).SubNewStatement.Modifiers.Any(SyntaxKind.SharedKeyword) Then
+                    If node.Kind() = SyntaxKind.SubNewStatement AndAlso
+                       DirectCast(node, SubNewStatementSyntax).Modifiers.Any(SyntaxKind.SharedKeyword) Then
                         Return Accessibility.Private
                     End If
 
                     Return Accessibility.Public
-
                 Case SyntaxKind.StructureBlock, SyntaxKind.InterfaceBlock, SyntaxKind.ModuleBlock
                     ' Everything in a struct/interface/module is public
                     Return Accessibility.Public
@@ -355,13 +399,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
             Return Accessibility.Internal
         End Function
 
-        Private Shared Function GetMethodSuffix(method As MethodBlockSyntax) As String
-            Return GetTypeParameterSuffix(method.SubOrFunctionStatement.TypeParameterList) &
-                   GetSuffix(method.SubOrFunctionStatement.ParameterList)
+        Private Shared Function GetMethodSuffix(method As MethodStatementSyntax) As String
+            Return GetTypeParameterSuffix(method.TypeParameterList) & GetSuffix(method.ParameterList)
         End Function
 
-        Private Shared Function GetConstructorSuffix(method As ConstructorBlockSyntax) As String
-            Return ".New" & GetSuffix(method.SubNewStatement.ParameterList)
+        Private Shared Function GetConstructorSuffix(method As SubNewStatementSyntax) As String
+            Return ".New" & GetSuffix(method.ParameterList)
         End Function
 
         Private Shared Function GetPropertySuffix([property] As PropertyStatementSyntax) As String
@@ -422,6 +465,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
             If parameterList IsNot Nothing Then
                 AppendParameters(parameterList.Parameters, builder)
             End If
+
             builder.Append(")"c)
 
             Return pooledBuilder.ToStringAndFree()
@@ -449,24 +493,22 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
             Next
         End Sub
 
-        Public Overrides Function GetReceiverTypeName(node As SyntaxNode) As String
-            Dim funcDecl = CType(node, MethodBlockSyntax)
+        Protected Overrides Function GetReceiverTypeName(node As StatementSyntax) As String
+            Dim funcDecl = DirectCast(node, MethodStatementSyntax)
             Debug.Assert(IsExtensionMethod(funcDecl))
 
-            Dim typeParameterNames = funcDecl.SubOrFunctionStatement.TypeParameterList?.Parameters.SelectAsArray(Function(p) p.Identifier.Text)
+            Dim typeParameterNames = funcDecl.TypeParameterList?.Parameters.SelectAsArray(Function(p) p.Identifier.Text)
             Dim targetTypeName As String = Nothing
             Dim isArray As Boolean = False
 
-            TryGetSimpleTypeNameWorker(funcDecl.BlockStatement.ParameterList.Parameters(0).AsClause?.Type, typeParameterNames, targetTypeName, isArray)
+            TryGetSimpleTypeNameWorker(funcDecl.ParameterList.Parameters(0).AsClause?.Type, typeParameterNames, targetTypeName, isArray)
             Return CreateReceiverTypeString(targetTypeName, isArray)
         End Function
 
-        Public Overrides Function TryGetAliasesFromUsingDirective(node As SyntaxNode, ByRef aliases As ImmutableArray(Of (aliasName As String, name As String))) As Boolean
-
-            Dim importStatement = TryCast(node, ImportsStatementSyntax)
+        Protected Overrides Function TryGetAliasesFromUsingDirective(importStatement As ImportsStatementSyntax, ByRef aliases As ImmutableArray(Of (aliasName As String, name As String))) As Boolean
             Dim builder = ArrayBuilder(Of (String, String)).GetInstance()
 
-            If (importStatement IsNot Nothing) Then
+            If importStatement IsNot Nothing Then
                 For Each importsClause In importStatement.ImportsClauses
 
                     If importsClause.Kind = SyntaxKind.SimpleImportsClause Then
@@ -511,7 +553,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
                 Dim genericName = DirectCast(node, GenericNameSyntax)
                 Dim name = genericName.Identifier.Text
                 Dim arity = genericName.Arity
-                simpleTypeName = If(arity = 0, name, name + GetMetadataAritySuffix(arity))
+                simpleTypeName = If(arity = 0, name, name + ArityUtilities.GetMetadataAritySuffix(arity))
                 Return True
 
             ElseIf TypeOf node Is QualifiedNameSyntax Then
@@ -576,7 +618,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.FindSymbols
             End Select
         End Function
 
-        Public Overrides Function GetRootNamespace(compilationOptions As CompilationOptions) As String
+        Protected Overrides Function GetRootNamespace(compilationOptions As CompilationOptions) As String
             Return DirectCast(compilationOptions, VisualBasicCompilationOptions).RootNamespace
         End Function
     End Class
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/FormattingHelpers.vb b/src/Workspaces/VisualBasic/Portable/Formatting/FormattingHelpers.vb
index 52bce4c858560..78f0fdc4232d9 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/FormattingHelpers.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/FormattingHelpers.vb
@@ -95,6 +95,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlElement.LessThanToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -105,6 +106,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlMemberAccess.Token2 = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -115,6 +117,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlElement.ColonToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -125,6 +128,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlElement.EqualsToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -135,6 +139,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlElement.EqualsToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -145,6 +150,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlElement.EqualsToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -155,6 +161,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlElement.LessThanToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -165,6 +172,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlElement.GreaterThanToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -175,6 +183,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlBracketedName.LessThanToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -185,6 +194,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlBracketedName.GreaterThanToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -199,6 +209,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If xmlElement.StartTag.LessThanToken = token Then
                     Return True
                 End If
+
                 Return False
             End If
 
@@ -210,6 +221,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                    IsGreaterThanInXmlTag(xmlElement.EndTag, token) Then
                     Return True
                 End If
+
                 Return False
             End If
 
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Rules/AlignTokensFormattingRule.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Rules/AlignTokensFormattingRule.vb
index be9c40376ee32..c8e10ad8ce202 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Rules/AlignTokensFormattingRule.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Rules/AlignTokensFormattingRule.vb
@@ -24,6 +24,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If tokens.Count > 1 Then
                     AddAlignIndentationOfTokensToBaseTokenOperation(operations, queryExpression, tokens(0), tokens.Skip(1))
                 End If
+
                 Return
             End If
         End Sub
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Rules/NodeBasedFormattingRule.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Rules/NodeBasedFormattingRule.vb
index c9c763d8b0044..b429560d3d29e 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Rules/NodeBasedFormattingRule.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Rules/NodeBasedFormattingRule.vb
@@ -282,6 +282,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                     foundXmlElement = True
                     Exit While
                 End If
+
                 previousToken = previousToken.GetPreviousToken(includeZeroWidth:=True)
             End While
 
@@ -515,8 +516,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
                 If forBlock Is node Then
                     Return count + 1
                 End If
+
                 count = count + 1
             Next
+
             Return count
         End Function
     End Class
diff --git a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb
index de3ec26cd0c74..bd37ccfb9a1a2 100644
--- a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb
@@ -135,6 +135,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Indentation
                 (containingToken.IsKind(SyntaxKind.CloseBraceToken) AndAlso token.Parent.IsKind(SyntaxKind.Interpolation)) Then
                 Return indenter.IndentFromStartOfLine(0)
             End If
+
             If containingToken.Kind = SyntaxKind.StringLiteralToken AndAlso containingToken.FullSpan.Contains(position) Then
                 Return indenter.IndentFromStartOfLine(0)
             End If
diff --git a/src/Workspaces/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj b/src/Workspaces/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj
index 2fc914af44c65..602bb056c19b5 100644
--- a/src/Workspaces/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj
+++ b/src/Workspaces/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj
@@ -5,7 +5,7 @@
     <OutputType>Library</OutputType>
     <TargetFrameworks>netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <RootNamespace></RootNamespace>
-    <ApplyNgenOptimization>partial</ApplyNgenOptimization>
+    <ApplyNgenOptimization Condition="'$(TargetFramework)' == 'netstandard2.0'">partial</ApplyNgenOptimization>
 
     <!-- NuGet -->
     <IsPackable>true</IsPackable>
diff --git a/src/Workspaces/VisualBasic/Portable/Recommendations/VisualBasicRecommendationServiceRunner.vb b/src/Workspaces/VisualBasic/Portable/Recommendations/VisualBasicRecommendationServiceRunner.vb
index 2ca6c7436ee81..6d52affd95f6f 100644
--- a/src/Workspaces/VisualBasic/Portable/Recommendations/VisualBasicRecommendationServiceRunner.vb
+++ b/src/Workspaces/VisualBasic/Portable/Recommendations/VisualBasicRecommendationServiceRunner.vb
@@ -211,6 +211,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Recommendations
             If container Is Nothing AndAlso TypeOf (leftHandTypeInfo.ConvertedType) Is IArrayTypeSymbol Then
                 container = leftHandTypeInfo.ConvertedType
             End If
+
             If container.IsErrorType() AndAlso leftHandSymbolInfo.Symbol IsNot Nothing Then
                 ' TODO remove this when 531549 which causes leftHandTypeInfo to be an error type is fixed
                 container = leftHandSymbolInfo.Symbol.GetSymbolType()
@@ -276,12 +277,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Recommendations
 
             Debug.Assert(Not excludeInstance OrElse Not useBaseReferenceAccessibility)
 
-            If _context.TargetToken.GetPreviousToken().IsKind(SyntaxKind.QuestionToken) Then
-                Dim type = TryCast(container, INamedTypeSymbol)
-                If type?.ConstructedFrom.SpecialType = SpecialType.System_Nullable_T Then
-                    container = type.GetTypeArguments().First()
-                End If
-            End If
+            ' On null conditional access, members of T for a Nullable(Of T) should be recommended
+            Dim unwrapNullable = _context.TargetToken.GetPreviousToken().IsKind(SyntaxKind.QuestionToken)
 
             ' No completion on types/namespace after conditional access
             If leftExpression.Parent.IsKind(SyntaxKind.ConditionalAccessExpression) AndAlso
@@ -297,7 +294,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Recommendations
                     .SelectMany(Function(n) LookupSymbolsInContainer(n, position, excludeInstance)) _
                     .ToImmutableArray()
             Else
-                symbols = GetMemberSymbols(container, position, excludeInstance, useBaseReferenceAccessibility)
+                symbols = GetMemberSymbols(container, position, excludeInstance, useBaseReferenceAccessibility, unwrapNullable)
             End If
 
             If excludeShared Then
@@ -353,6 +350,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Recommendations
             ElseIf s.Kind = SymbolKind.NamedType AndAlso s.IsImplicitlyDeclared Then
                 Return Not TypeOf DirectCast(s, INamedTypeSymbol).AssociatedSymbol Is IEventSymbol
             End If
+
             Return True
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/Rename/LocalConflictVisitor.vb b/src/Workspaces/VisualBasic/Portable/Rename/LocalConflictVisitor.vb
index 09ab4fe62a505..d54f734454013 100644
--- a/src/Workspaces/VisualBasic/Portable/Rename/LocalConflictVisitor.vb
+++ b/src/Workspaces/VisualBasic/Portable/Rename/LocalConflictVisitor.vb
@@ -73,6 +73,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Rename
             For Each clause In node.Clauses
                 Visit(clause)
             Next
+
             _tracker.RemoveIdentifiers(tokens)
         End Sub
 
@@ -94,6 +95,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Rename
             For Each statement In block
                 Visit(statement)
             Next
+
             _tracker.RemoveIdentifiers(tokens)
         End Sub
 
diff --git a/src/Workspaces/VisualBasic/Portable/Rename/VisualBasicRenameRewriterLanguageService.vb b/src/Workspaces/VisualBasic/Portable/Rename/VisualBasicRenameRewriterLanguageService.vb
index 99e3d9f333331..6939f97f48342 100644
--- a/src/Workspaces/VisualBasic/Portable/Rename/VisualBasicRenameRewriterLanguageService.vb
+++ b/src/Workspaces/VisualBasic/Portable/Rename/VisualBasicRenameRewriterLanguageService.vb
@@ -1033,6 +1033,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Rename
                     Return Nothing
                 End If
             End If
+
             Dim isInNamespaceOrTypeContext = SyntaxFacts.IsInNamespaceOrTypeContext(TryCast(syntax, ExpressionSyntax))
             Dim position = nodeToSpeculate.SpanStart
             Return SpeculationAnalyzer.CreateSpeculativeSemanticModelForNode(nodeToSpeculate, DirectCast(originalSemanticModel, SemanticModel), position, isInNamespaceOrTypeContext)
diff --git a/src/Workspaces/VisualBasic/Portable/Serialization/VisualBasicOptionsSerializationService.vb b/src/Workspaces/VisualBasic/Portable/Serialization/VisualBasicOptionsSerializationService.vb
index 7d57111fce0ca..e3689929d2b48 100644
--- a/src/Workspaces/VisualBasic/Portable/Serialization/VisualBasicOptionsSerializationService.vb
+++ b/src/Workspaces/VisualBasic/Portable/Serialization/VisualBasicOptionsSerializationService.vb
@@ -122,6 +122,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Serialization
                 Dim value = reader.ReadValue()
                 builder.Add(KeyValuePairUtil.Create(key, value))
             Next
+
             Dim options = New VisualBasicParseOptions(languageVersion, documentationMode, kind, builder.MoveToImmutable())
             Return options.WithFeatures(features)
         End Function
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/Simplifiers/AbstractVisualBasicSimplifier.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Simplifiers/AbstractVisualBasicSimplifier.vb
index a04f9b6d0efd6..9e0183be63796 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/Simplifiers/AbstractVisualBasicSimplifier.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Simplifiers/AbstractVisualBasicSimplifier.vb
@@ -176,6 +176,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification.Simplifiers
                     Return True
                 End If
             End If
+
             Return False
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicSimplificationService.Expander.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicSimplificationService.Expander.vb
index 0fb536a4880ed..1bdd54ae70f13 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicSimplificationService.Expander.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicSimplificationService.Expander.vb
@@ -365,6 +365,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                             ' No duplicate names allowed
                             Return False
                         End If
+
                         found = True
                     End If
                 Next
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicSimplificationService.NodesAndTokensToReduceComputer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicSimplificationService.NodesAndTokensToReduceComputer.vb
index 84204be78a458..92d5adb9d8e09 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicSimplificationService.NodesAndTokensToReduceComputer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicSimplificationService.NodesAndTokensToReduceComputer.vb
@@ -73,6 +73,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                     Me._simplifyAllDescendants Then
                         Me._nodesAndTokensToReduce.Add(New NodeOrTokenToReduce(node, False, node, False))
                     End If
+
                     node = MyBase.Visit(node)
                 End If
 
@@ -127,6 +128,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                     Function(n, b, s, e)
                         Return DirectCast(n, MethodBlockSyntax).Update(node.Kind, DirectCast(b, MethodStatementSyntax), s, e)
                     End Function
+
                 Return VisitMethodBlockBaseSyntax(node, updateFunc)
             End Function
 
@@ -135,6 +137,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                     Function(n, b, s, e)
                         Return DirectCast(n, OperatorBlockSyntax).Update(DirectCast(b, OperatorStatementSyntax), s, e)
                     End Function
+
                 Return VisitMethodBlockBaseSyntax(node, updateFunc)
             End Function
 
@@ -143,6 +146,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                     Function(n, b, s, e)
                         Return DirectCast(n, ConstructorBlockSyntax).Update(DirectCast(b, SubNewStatementSyntax), s, e)
                     End Function
+
                 Return VisitMethodBlockBaseSyntax(node, updateFunc)
             End Function
 
@@ -151,6 +155,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                     Function(n, b, s, e)
                         Return DirectCast(n, AccessorBlockSyntax).Update(node.Kind, DirectCast(b, AccessorStatementSyntax), s, e)
                     End Function
+
                 Return VisitMethodBlockBaseSyntax(node, updateFunc)
             End Function
 
diff --git a/src/Workspaces/VisualBasicTest/CodeGeneration/AddImportsTests.vb b/src/Workspaces/VisualBasicTest/CodeGeneration/AddImportsTests.vb
index 0a07e36f07f5e..d3038b363a9a3 100644
--- a/src/Workspaces/VisualBasicTest/CodeGeneration/AddImportsTests.vb
+++ b/src/Workspaces/VisualBasicTest/CodeGeneration/AddImportsTests.vb
@@ -51,6 +51,7 @@ End NameSpace"
                                              If symbol IsNot Nothing Then
                                                  Return c.WithAdditionalAnnotations(SymbolAnnotation.Create(symbol), Simplifier.Annotation)
                                              End If
+
                                              Return c
                                          End Function)
                 doc = doc.WithSyntaxRoot(root)
diff --git a/src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb b/src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb
index e12dda6b0c2e9..d738e02bd7908 100644
--- a/src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb
+++ b/src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb
@@ -2553,6 +2553,18 @@ End Class
             Assert.Equal(DeclarationModifiers.None, Generator.GetModifiers(Generator.WithModifiers(SyntaxFactory.TypeParameter("tp"), DeclarationModifiers.Abstract)))
         End Sub
 
+        <Fact>
+        Public Sub TestWithModifiers_Sealed()
+            Dim classBlock = DirectCast(Generator.ClassDeclaration("C"), ClassBlockSyntax)
+            Dim classBlockWithModifiers = Generator.WithModifiers(classBlock, DeclarationModifiers.Sealed)
+            VerifySyntax(Of ClassBlockSyntax)(classBlockWithModifiers, "NotInheritable Class C
+End Class")
+
+            Dim classStatement = classBlock.ClassStatement
+            Dim classStatementWithModifiers = Generator.WithModifiers(classStatement, DeclarationModifiers.Sealed)
+            VerifySyntax(Of ClassStatementSyntax)(classStatementWithModifiers, "NotInheritable Class C")
+        End Sub
+
         <Fact>
         Public Sub TestGetType()
             Assert.Equal("t", Generator.GetType(Generator.MethodDeclaration("m", returnType:=Generator.IdentifierName("t"))).ToString())
diff --git a/src/Workspaces/VisualBasicTest/VisualBasicExtensionsTests.vb b/src/Workspaces/VisualBasicTest/VisualBasicExtensionsTests.vb
index 91f875cafeea6..97b144173b464 100644
--- a/src/Workspaces/VisualBasicTest/VisualBasicExtensionsTests.vb
+++ b/src/Workspaces/VisualBasicTest/VisualBasicExtensionsTests.vb
@@ -23,6 +23,7 @@ Module Module1
             For i = 0 To 3000
                 code.Append("""asdf"" + ")
             Next
+
             code.AppendLine(<![CDATA["last"
     End Sub
 End Module]]>.Value)